Newsgroup: it.comp.lang.c++
Titolo: spiegazioni sul costruttore di una classe

leggo continuamente che il costruttore di una classe viene richiamato
"automaticamente" quando si istanzia l'oggetto,
ma la parola in automatico può essere più precisa...
qualche buon'anima sa spiegarmi come si può richiamare il costruttore
di una classe, meglio,
in che modo l'operatore "new" riesce a richiamalo,
e se questo si chiama in automatico, da chi viene chiamato?
grazie duido


Se allochi in modo "normale", il:
- MiaClasse a(x,y,z);
puo' essere letto come:
- [alloca abb spazio sullo stack per un MiaClasse]
- [chiama il costruttore per quel MiaClasse]
Se invece allochi con new, allora il:
- MiaClasse *aa = new MiaClasse(x,y,z)
puo' essere letto come:
- [alloca abb spazio sull'heap per un MiaClasse]
- [chiama il costruttore per quel MiaClasse]
- [assegna un puntatore allo spazio assegnato, ad "aa"]
Non puoi mai chiamare il costruttore in maniera diretta (ed e' giusto 
cosi', se ci pensi).
new "riesce a richiamarlo" perche' cosi' e' scritto nelle specifiche del 
linguaggio, e "chi lo chiama" e' nessuno - anche qui, e' scritto nelle 
specifiche del linguaggio che deve succedere, ed il codice compilato fa 
in modo che succeda... cmq non mi e' chiarissimo cosa intendessi con le 
tue domande: spero tuttavia che il semplice schemino sopra ti aiuti a 
capire :P
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://www.cs.unibo.it/~mbellett
Linux registered user 299762 @ Linux registered machine 213003

questo è quello che ho capito,
l'allocazione con new permette di inizializzare l'oggetto con il
costruttore,
l'allocazione con malloc non lo permette, anche se lo spazio per
l'oggetto viene allocato
chi chiama il costruttore specifico?
risposta... il linguaggio C++
questa curiosità la sto approfondendo perchè quando utilizzo i
template ho un comportamento di allocazione che non capisco, forse
l'allocazione è gestita in maniera diversa da una semplice classe,
sto implementando una lista template per poter riutilizzare il codice
della lista, ma durante la deallocazione non funziona, errore di
overflow stack,
la stessa lista implementata con le classi funziona.
specifico che la lista Template, se nell'allocazione sostituisco
"malloc"  a "new" tutto funziona perfettamente come nella lista
implementata con le classi.
cosa significa?
il template viene allocato nello stak anche se utilizzo new?
grazie duido.

 il template viene allocato nello stack anche se utilizzo new?
Significa che hai fatto qualche errore nella liberazione della memoria, 
ma senza il tuo codice ne' palle di cristallo, nessuno sara' mai in 
grado di dirti _quale_ errore hai fatto :)


CProva{
int s;
public:
CProva(){}
CProva(int x){ s= x;}
~CProva(){}
};
riassumento i 2 metodi ottengono lo stesso risultato?
allocazione con "new"
CProva *ptr;
ptr= new CProva(3);
delete ptr;
allocazione con "malloc"
CProva *ptr,obProva(3);
ptr= (CProva()*)malloc( 1, sizeof(CProva()) );
*ptr= obProva;
free( ptr);
grazie ancora duido

 
No. Se usi 'new'/'delete' l'oggetto viene costruito e distrutto. Se usi 
'malloc'/'free', nessun oggetto viene in realtà costruito (ossia non viene 
invocato alcun costruttore), ma viene soltanto allocato un blocco di 
memoria di una certa dimensione. 
Nel caso particolare in cui costruttore e distruttore (dell'oggetto e dei 
suoi membri dati) non fanno assolutamente niente, non vi sarà differenza 
visibile, ma in generale per allocare dinamicamnete un oggetto si deve 
usare 'new'/'delete'.
Max

 cosi', se ci pensi).
Perchè invece si puo' invocare un distruttore ?  { A a; a.~A(); }


Sì, ma ha senso farlo soltanto se il distruttore non viene chiamato
implicitamente. (Quindi *non* nel tuo esempio.)
Se un oggetto è creato mediante 'placement new' (v. manuale o Google per
maggiori informazioni), dovrà essere distrutto invocando esplicitamente il
distruttore.
  #include <new>
  char* memory = new char[ sizeof(A) ];
  A* a = new (memory) A; // costruisce un oggetto di tipo A
                         // nella zona di memoria di 'memory'
  a->~A();               // distrugge l'oggetto
  delete[] memory;       
Max

"alef" <al...@localhost.nowhere> ha scritto nel messaggio
news:StwHc.75056$G%.44592@tornado.fastwebnet.it...

L'affermazione di cui sopra è sbagliata. E'possibile invocare esplicitamente
un costruttore, e ciò ha l'effetto di creare
un oggetto temporaneo che viene distrutto al termine dell'espressione
completa in cui compare.
Per esempio:
A ogg = A( )  +  A ( );
pone in ogg la "somma" si due oggetti di classe A temporanei (ammesso che
sia definito un operatore + per tali oggetti.
Ciao,
Plautus

 completa in cui compare.
Penso che Mattia intendesse "chiamare un costruttore da un'istanza";
qualcosa tipo a.() o a.A(). Da qui la simmetria della mia domanda sul
distruttore.
-- 
http://www.parashift.com/c++-faq-lite/
http://mindview.net/Books/DownloadSites
http://www.cppreference.com/

 distruttore.
Exactly, la prossima volta mi esprimero' meglio ;)

 
ti ringrazio molto,
sta roba non l'ho mai vista da nessuna parte...
adesso me la provo,
bye duido