Newsgroup: it.comp.lang.c++
Titolo: Un bel quesito teorico per voi

Ciao a tutti,
Visto che vi piacciono tanto i quesiti teorici ecco uno tutto per voi
Io ho una classe con un bel costruore che acceta un paramentro float
pero compreso tra 0.0f e 1.0f ho pensato di controlare il paramentro
con una bella if e di lanciare un eccezione se il valore non è
compreso tra questi due estremi la mia domanda è:
Devo dire il quanlche modo di distrugere l'oggeto che stava creando? o
ci pensa il compilatore di suo?
Se devo farlo io come? chiamando il distruttore? supongo prima di
chiamre l'eccezione
voi che mi consigliate?
Il Razziatore,
The Only Good Windows is an uninstalled Windows
-----------------------------------------------
E-MAILs : IlRazziat...@NOSPAMnetscape.net
ICQ     : 67552596
-----------------------------------------------
Founder of MediaPlayer Project
http://mpp.iwebland.com

> Visto che vi piacciono tanto i quesiti teorici ecco uno tutto per
voi
Visto che ti piace provocare in modo molto stupido, non ti rispondo e
ti dico che ai messaggi bisogna dare un subject significativo.

 ci pensa il compilatore di suo?
Io ho fatto una piccola prova per simulare il tuo quesito (che mi ha 
incuriosito), e - se non ho commesso errori - mi pare che il distruttore 
dell'oggetto la cui costruzione fallisce per il lancio di un'eccezione 
*non* viene chiamato automaticamente dal compilatore.
Dan

 Il Razziatore,
ciao,
Nids
ps: RTFM!!!!!!!!!!!!!!!!!!!!!!!!!

Dan
Uhm tu dici che non viene chiamato ma nids dice che sencodo lo
standard si... mumble... mi sa che faro anche io le prove e tanti
saluti al quesito teorico!
tanto per sapere { se non č OT ovvio } che compilatore usi?


come nel caso dei puntatori:
tks


         p = std::auto_ptr<int>( new int[10] );
No! auto_ptr<> è  per gli oggetti singoli, non per gli array. Se cerchi di 
usarlo con array hai un comportamento indefinito.
Max

 standard si... mumble
Il distruttore della classe nel cui costruttore è partita un'eccezione NON 
viene invocato. 
Tutte le parti di oggetto che all'ingresso del costruttore erano già state 
costruite vengono invece distrutte: quindi verranno prima invocati i 
distruttori dei membri dati e poi i distruttori delle classi base.
 class A : public AB
 {
      B  b;
      D* d
        A() 
        {
            C c;
            d = new D;
            throw "X";
         }
 };
Quando si tenta di instanziare A, accade quanto segue:
  - ctor AB
  - ctor B
  - ctor C
  - ctor D
  - throw
  - dtor C
  - dtor B
  - dtor AB
Max

 viene invocato. 
Infatti... e' la stessa cosa che avevo detto io :-)

 standard si... 
Ti ha risposto come me anche Max M.
Ciao
Dan

 ha scritto nel messaggio
news:c027bn$75m$1...@newsreader.mailgate.org...

Hai perfettamente ragione, ho sbagliato nel copiare ed incollare gli esempi
che mi ero fatto:
il primo era:
<CODE>
#include <iostream>
class B{
public:
    B(){ std::cout<<"ciao, sono il costruttore di B!"<<std::endl; }
    ~B(){ std::cout<<"ciao, sono il distuttore di B!"<<std::endl; }
};
class A{
public:
    A(){
        B b;
        std::cout<<"ciao, sono il costruttore di A!"<<std::endl;
        throw "errore";
    }
    ~A() { std::cout<<"ciao, sono il costruttore di A!"<<std::endl; }
};
int main(){
    try{
        A a;
    }catch(char* e){ std::cout<<"catch di : "<<e<<"!"<<std::endl; }
    return 0;
}
</CODE>
<OUTPUT>
ciao, sono il costruttore di B!
ciao, sono il costruttore di A!
ciao, sono il distuttore di B!
catch di : errore!
</OUTPUT>
il secondo (con i puntatori) che non cancella B:
<CODE>
#include <iostream>
class B{
public:
    B(){ std::cout<<"ciao, sono il costruttore di B!"<<std::endl; }
    ~B(){ std::cout<<"ciao, sono il distuttore di B!"<<std::endl; }
};
class A{
public:
    A(){
        b = new B();
        std::cout<<"ciao, sono il costruttore di A!"<<std::endl;
        throw "errore";
    }
    ~A() { std::cout<<"ciao, sono il costruttore di A!"<<std::endl; }
private:
    B *b;
};
int main(){
    try{
        A a;
    }catch(char* e){ std::cout<<"catch di : "<<e<<"!"<<std::endl; }
    return 0;
}
</CODE>
<OUTPUT>
ciao, sono il costruttore di B!
ciao, sono il costruttore di A!
catch di : errore!
</OUTPUT>
Ed infine il terzo con gli auto_ptr che cancella B:
<CODE>
#include <iostream>
#include <memory>
class B{
public:
    B(){ std::cout<<"ciao, sono il costruttore di B!"<<std::endl; }
    ~B(){ std::cout<<"ciao, sono il distuttore di B!"<<std::endl; }
};
class A{
public:
    A(){
        b = std::auto_ptr<B>( new B()) ;
        std::cout<<"ciao, sono il costruttore di A!"<<std::endl;
        throw "errore";
    }
    ~A() { std::cout<<"ciao, sono il costruttore di A!"<<std::endl; }
private:
    std::auto_ptr<B> b;
};
int main(){
    try{
        A a;
    }catch(char* e){ std::cout<<"catch di : "<<e<<"!"<<std::endl; }
    return 0;
}
</CODE>
<OUTPUT>
ciao, sono il costruttore di B!
ciao, sono il costruttore di A!
ciao, sono il distuttore di B!
catch di : errore!
</OUTPUT>
Per poter gestire array, in maniera sicura dal punto di vista delle
eccezioni, e' consigliato usare, al posto degli array, i vector.
Mi scuso ancora per la non correttezza degli esempi precedenti ma dato che
erano le 1:45 la stanchezza mi ha fatto copiare gli esempi sbagliati.
Ciao,
Nids

 wrote:
[ CUT ]
Grazie a tutti
