Newsgroup: it.comp.lang.c++
Titolo: Chiamata costruttore

Con new si ha la certezza che venga chiamato il costruttore. Ma anche quando
dichiaro normalmente un oggetto, quindi anche quando è un paramentro(per
valore) di una funzione?
--
Marco Iannaccone     
marc...@tin.it
ICQ: 18748121           Tolkien
"I've... seen things you people wouldn't believe. Attack ships on fire off
the shoulder of Orion.
I watched C-beams... glitter in the dark near the Tanhauser Gate. All
those... moments will be lost... in time..., like... tears... in... rain."
FAQ it.comp.lang.c: 
http://www.programmazione.it/linguaggi/c/itcomplangc.htm
FAQ it.comp.lang.c++: 
http://www.programmazione.it/linguaggi/c/lang_faq.htm


Intendi dire quando scrivi
Myclass *ptr = new Myclass(...);
 ?
Sě, qui il costruttore viene chiamato, e viene chiamato anche durante
l'istanziazione statica, ad es.
Myclass obj;
ed ogniqualvolta venga istanziato un oggetto
Ciao
Domenico

 valore) di una funzione?
Spero di aver capito a cosa ti riferisci e di ricordare i dettagli
dell'argomento. Nel programma
class A { [...] };
void fn( A );
int main()
{
    A a;
    fn( a );
    return 0;
}
quando si fa la chiamata "fn(a)", alla funzione viene passata una copia
dell'istanza "a". Questa copia viene ottenuta con una chiamata implicita al
costruttore di copia (in inglese copy-constructor) della classe A, quindi in
effetti c'è la chiamata ad un costruttore.
Il copy-constructor di una classe A è un costruttore del tipo A(A&), ovvero
un costruttore che accetta un riferimento ad un'istanza di A come unico
parametro. Serve ad inizializzare una nuova istanza di A sui dati
dell'oggetto passato come argomento. Se non viene definito esplicitamente,
il compilatore provvede a crearne uno di default.
--
Piergiorgio Pirro
piergior...@tin.it
http://web.tiscalinet.it/ppirro
ICQ# 60945968

Il copy-constructor di una classe A è un costruttore del tipo A(A&),
Il tipo e' A(const A&)
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 Il copy-constructor di una classe A è un costruttore del tipo A(A&),
Non era A( const A& )?
EMG

 Sì, qui il costruttore viene chiamato, e viene chiamato anche durante


 Non era A( const A& )?
Non sempre...
Ciao,
Nicola

 Non sempre...
Grazie a quelli che hanno corretto la mia svista, e... Che significa "non
sempre"?


sempre"?
Che un costruttore di copia può essere dichiarato anche come
A(A& obj);
Così, durante la copia, ho la possibilità di modificare l'oggetto originale
(moolto discutibile, dal punto di vista della correttezza...)
Ciao!
Domenico

(moolto discutibile, dal punto di vista della correttezza...)
La cosa creerebbe non pochi problemi in quanto risulterebbe
vietato copiare un valore da un oggetto temporaneo o costante.
Su BCC55 ad esempio il seguente codice:
   #include <iostream>
   #include <vector>
   struct A
   {
     int x,y;
     A& operator=(A& other)
     {
       x=other.x; y=other.y;
       return *this;
     }
   };
   int main()
   {
     std::vector<A> v;
     v.push_back(A());
     return 0;
   }
Non risulta compilabile (std::vector richiede che
l'oggetto contenuto preveda un copy constructor che
accetti un const reference).


 ...


vietato copiare un valore da un oggetto temporaneo o costante.
Già, ma è sempre possibile fornire entrambi i costruttori per copia:
A(const a&)
A(a&)
Al momento della copia, verrà scelto il costr. più adatto.
Ripeto che però la modifica "selvaggia" di un parametro di una funzione è
una cosa che non condivido.
Ciao ;)
Domenico

una cosa che non condivido.
Dipende dalla funzione; se e' chiarissimo dal nome della
funzione che i parametri sono modificati allora non vedo
nessun problema (es. swap(A&,A&)).
Dall'operatore di assegnazione e dal costruttore di copia
pero' non mi aspetto cose strane.
In realta' come mi e' stato fatto notare esiste un caso
"patologico" in cui questa scelta e' stata fatta dallo
standard C++: auto_ptr.
Personalmente non credo che pero' in un sorgente dovrebbero
mai comparire dichiarazioni del tipo:
    A(A&);
    A& operator=(A&);
in quanto o sono stati dimenticati un paio di "const"
oppure ci si e' dimenticato di mettere una decina di
righe di commento che giustificano queste dichiarazioni
"anomale" in quello specifico caso.


    A& operator=(A&);
E anche in questo siamo perfettamente d'accordo ;-)
Ciao
Domenico