[C++] Come uscire dal flusso nel costruttore

[mlipreri]

Ciao ho il costruttore della mia classe che fa delle operazioni, se alcune di queste operazioni non vanno a buon fine non sussitono
le precondizioni per eseguire il restante flusso, come faccio ad uscire dal costruttore quando si verifica ciò?
Mi trovo in difficoltà perchè se fossi stato in una normale funzione avrei semplicemente eseguito un return false, ma qui non posso
far ritornare niente.
Grazie

[Ed_Bunker]

Ehm... a dire il vero dovrebbero essere i metodi a fare eventuali controlli sulle caratteristiche dell'oggetto precedentemente istanziato.
Nel costruttore l'oggetto viene appunto creato per cui non c'e' proprio la necessita' di avere delle precondizioni (Che infatti MAI vengono indicate in un costruttore bensi' "solo" nei metodi ai quali quel tipo di oggetto ha "accesso").
In un costruttore non "devono" essere effettuate delle operazioni ma soltanto delle inizializzazioni che servono ad impostare una o piu' proprieta' dell'oggetto da creare.

[MItaly]

Originariamente inviato da Ed_Bunker
In un costruttore non "devono" essere effettuate delle operazioni ma soltanto delle inizializzazioni che servono ad impostare una o piu' proprieta' dell'oggetto da creare.

Be', le inizializzazioni spesso implicano anche delle operazioni complesse e che possono non andare a buon fine; se si riscontrano problemi in un costruttore, comunque, di solito si solleva un'eccezione.

[oNaSsI$]

richiamare il distruttore?

[MItaly]

Che io sappia il distruttore non può essere richiamato direttamente, e comunque non risolverebbe il problema: l'oggetto sarebbe comunque creato.

[GreyFox86]

Fai come dice MItaly, solleva una bella eccezione.

esempio

class Eccezione { };
class A {
public:
	A(int x) {
		if (x<0) throw Eccezione;
		// ...
	}
	/..
};

//da qualche parte:
try {
	A a(-23);
} catch (Eccezione) {
	//cosa fare se viene sollevata l'eccezione
}

[shodan]

La cosa migliore è catturare l'eccezione nel costruttore e settare un flag.

class A {
   public: 
       A() : p(0), k(0) {
           p = new int;  // questo funge

           k = new int;  // questo solleva una bad_alloc

       }

       ~A() {
           delete p;
           delete k;
       }

    private:
        int* p;
        int* k;

};

se l'eccezione non viene catturata nel costruttore, nessuno libera la memoria di p. In più l'esecuzione si arresta al momento dell'eccezione e l'oggetto rimane incompleto e il distruttore non è invocato.

Un modo un pò laborioso è il seguente.

class A {
   public: 
       A() : p(0), k(0),init_ok(false) {
           try {
               p = new int;  // questo funge
           } catch (std::bad_alloc& err) {
               p=0;
               init_ok = false;
           }

           try {
               k = new int;  // questo solleva una bad_alloc
           } catch (std::bad_alloc& err) {
              k=0; 
              init_ok = false;
           }
           init_ok = true;
       }

       ~A() {
           delete p;
           delete k;
       }
       bool ok() const { return init_ok;}
    private:
        int* p;
        int* k;
        bool init_ok;
};

In questo caso l'eccezione è catturata e si setta il flag per poi controllarlo in un punto esterno del codice. (Ed eventualmente lanciare una successiva eccezione).
Questo garantisce che il distruttore venga richiamato sempre.

[Ed_Bunker]

Originariamente inviato da MItaly
Be', le inizializzazioni spesso implicano anche delle operazioni complesse e che possono non andare a buon fine; se si riscontrano problemi in un costruttore, comunque, di solito si solleva un'eccezione.

In un costruttore non dovrebbero essere previste "operazioni complesse" (E bisognerebbe capire cosa si intenda per complessita'".

Se poi si ipotizza che qualcosa possa andar storto durante la creazione dell'oggetto allora bata prevedere una proprieta' che stia ad indicare proprio se tutto e' andato bene.

Basterebbe ad esempo un flag che tramite un 'getter' restituisca, quando invocato su una determinata istanza, lo "stato" dell'istanza stessa.

Imho e' un modo molto piu' "chiaro e pulito" di approcciare il problema.

[mlipreri]

grazie per le delucidazioni, il mio costruttore deve fare molte operazioni e quindi ho spostato il tutto in funzioni esterne private e ho lasciato al costruttore il solo compito di inzializzazione degli attributi.
thx

[Ed_Bunker]

Originariamente inviato da mlipreri
grazie per le delucidazioni, il mio costruttore deve fare molte operazioni e quindi ho spostato il tutto in funzioni esterne private e ho lasciato al costruttore il solo compito di inzializzazione degli attributi.
thx