|
|
|
|
Strumenti |
26-12-2009, 14:45 | #1 |
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
[C++] Dubbi su costruttori, tipi di ritorno e union
Innanzitutto tanti auguri a tutti gli utenti del forum.
Sto seguendo questo tutorial: LINK Tra ieri e l'altro ieri ho letto la parte relativa alle classi (parte I e II) e non ho capito alcune cose. Provo a fare una lista: 1. Come funziona una union usata come classe? Se ho ben capito i membri di tipo dato occupano tutti la stessa area di memoria, mentre le funzioni membro occupano uno spazio a parte (questo lo immagino io, nel tutorial non lo spiega). E' corretto? 2. A cosa serve usare un riferimento come tipo di ritorno di una funzione? Aggiungo più avanti un esempio che riassume questa e la prossima domanda. 3. Qual è il ciclo di vita di un oggetto in C++? Sono abituato al java in cui finchè esiste un riferimento all'oggetto questo non viene distrutto, qui invece se ho capito bene se l'oggetto è instanziato con new permane in memoria finchè non viene deallocato con delete, se invece è dichiarato come variabile locale permane solo nel blocco in cui è dichiarato. I dubbi 2 e 3 mi sono venuti dopo aver letto questo esempio del tutorial: Codice:
// vectors: overloading operators example #include <iostream> using namespace std; class CVector { public: int x,y; CVector () {}; CVector (int,int); CVector operator + (CVector); CVector& operator = (const CVector&); }; CVector::CVector (int a, int b) { x = a; y = b; } CVector CVector::operator+ (CVector param) { CVector temp; temp.x = x + param.x; temp.y = y + param.y; return (temp); } CVector& CVector::operator= (const CVector& param) { x=param.x; y=param.y; return *this; } int main () { CVector a (3,1); CVector b (1,2); CVector c; c = a + b; cout << c.x << "," << c.y; return 0; } 4. Ho arricchito il codice sopra per tentare di capire alcune cose e questo è il risultato (che non capisco): Codice:
// vectors: overloading operators example #include <iostream> using namespace std; class CVector { public: static int n; int x,y; CVector () { n++; cout << "+" << endl; }; CVector (int,int); ~CVector() { n--; cout << "-" << endl; }; CVector operator + (CVector); //CVector& operator= (const CVector& param); }; int CVector::n=0; CVector::CVector (int a, int b) { n++; cout << "+" << endl; x = a; y = b; } CVector CVector::operator+ (CVector param) { CVector temp; temp.x = x + param.x; temp.y = y + param.y; cout << "operator+: " << CVector::n << endl; return (temp); } /*CVector& CVector::operator= (const CVector& param) { x=param.x; y=param.y; return *this; }*/ int main () { CVector a (3,1); CVector b (1,2); CVector c; cout << "Dichiarazioni variabili locali: " << CVector::n << endl; c = a + b; cout << a.x << "," << a.y <<endl; cout << b.x << "," << b.y <<endl; cout << c.x << "," << c.y <<endl; cout << "Fine: " << CVector::n << endl; return 0; } Codice:
+ + + Dichiarazioni variabili locali: 3 + operator+: 4 - - 3,1 1,2 4,3 Fine: 2 - - - Process returned 0 (0x0) execution time : 0.147 s Press any key to continue. Sono molte domande quindi anche se mi rispondete poco per volta va bene. Grazie e ancora auguri! |
27-12-2009, 13:25 | #2 |
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
Ho letto parte di un altro libro e ho trovato un po' di risposte...
Riguardo la 1 era corretto come immaginavo. Sulla 2: Nel caso dell'assegnazione è utile per poter concatenare più assegnazioni, infatti prendono come parametro un riferimento, quindi l'unico modo è restituire un riferimento. Ho trovato casi in cui si restituiscono riferimenti solo in overload di operatori. Se avete modo di chiarire ulteriormente la questione le vostre informazioni sono ben accolte. Riguardo la 4: ci sono 4 + e 5 - perché nell'overload dell'operatore + quando viene ritornato temp in realtà non viene ritornato temp stesso ma viene richiamato un costruttore automatico (che quindi crea un nuovo oggetto) di cui non ho fatto l'overload (si tratta della memberwise initialization se la mia fonte è corretta) e di conseguenza non viene stampato il + corrispondente. Per lo stesso motivo non viene incrementato n e quindi nelle stampe successive risulta che siano allocati 2 oggetti nonostante se ne possano stampare 3. Sulla 3 invece ancora non ho capito bene... Quello che mi manda in confusione è il fatto che a volte le funzioni ritornino un oggetto, come nel punto 4, e in quel caso non ho capito quando l'oggetto viene distrutto: forse al termine del blocco che ha richiamato la funzione? Ad ogni modo se ho sbagliato qualcosa correggetemi, ci tengo molto a capire bene tutto. |
27-12-2009, 13:39 | #3 |
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
Ripensandoci il punto 4 ancora non torna...
Allora, nel main vengono creati 3 oggetti, poi nell'overload dell'operatore + (lo riporto qui) Codice:
CVector CVector::operator+ (CVector param) { CVector temp; temp.x = x + param.x; temp.y = y + param.y; cout << "operator+: " << CVector::n << endl; return (temp); } Ora viene richiamata la funzione = che non distrugge c ma gli assegna gli stessi valori dell'oggetto che è stato ritornato dalla funzione + (è proprio lo stesso oggetto perché stavolta param è passato per riferimento). Quindi si ritorna nel main dove vengono stampati i 3 oggetti e viene stampato n che giustamente vale 2. Ma di oggetti in memoria al momento dovrei averne 4: a,b,c e la copia di temp che era stata ritornata dalla funzione +. Quindi perché alla fine vengono richiamati solo 3 distruttori (i 3 "-" finali)? |
27-12-2009, 14:01 | #4 |
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
Ho fatto un'altra prova, ho sovrascritto il costruttore automatico di inizializzazione, ecco il codice e l'output:
Codice:
// vectors: overloading operators example #include <iostream> using namespace std; class CVector { public: static int n; int x,y; CVector () { n++; cout << "+" << endl; }; CVector (const CVector &cv) : x(cv.x),y(cv.y){ n++; cout << "Memberwise initialization" << endl; cout << "+" << endl; } CVector (int,int); ~CVector() { n--; cout << "-" << endl; }; CVector operator + (CVector); CVector& operator= (const CVector& param); }; int CVector::n=0; CVector::CVector (int a, int b) { n++; cout << "+" << endl; x = a; y = b; } CVector CVector::operator+ (CVector param) { CVector temp; temp.x = x + param.x; temp.y = y + param.y; cout << "operator+: " << CVector::n << endl; return (temp); } CVector& CVector::operator= (const CVector& param) { x=param.x; y=param.y; cout << "operator=: " << CVector::n << endl; return *this; } int main () { CVector a (3,1); CVector b (1,2); CVector c; cout << "Dichiarazioni variabili locali: " << CVector::n << endl; c = a + b; cout << a.x << "," << a.y <<endl; cout << b.x << "," << b.y <<endl; cout << c.x << "," << c.y <<endl; cout << "Fine: " << CVector::n << endl; return 0; } Codice:
+ + + Dichiarazioni variabili locali: 3 Memberwise initialization + + operator+: 5 operator=: 5 - - 3,1 1,2 4,3 Fine: 3 - - - Process returned 0 (0x0) execution time : 0.103 s Press any key to continue. |
27-12-2009, 14:21 | #5 |
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
Ho scritto un codice ancora più completo. Eccolo, con l'output:
Codice:
// vectors: overloading operators example #include <iostream> using namespace std; class CVector { public: static int n; static int tot; int x,y,id; CVector () : id(tot) { tot++; n++; cout << "id: " << id << " +" << endl; }; CVector (const CVector &cv) : x(cv.x),y(cv.y),id(tot){ tot++; n++; cout << "Memberwise initialization" << endl; cout << "id: " << id << " +\tx: " << x << " y: " << y << endl; } CVector (int,int); ~CVector() { n--; cout << "id: " << id << " -\tx: " << x << " y: " << y << endl; }; CVector operator + (CVector); CVector& operator= (const CVector& param); }; int CVector::n=0; int CVector::tot=0; CVector::CVector (int a, int b) : x(a),y(b),id(tot) { tot++; n++; cout << "id: " << id << " +\tx: " << x << " y: " << y << endl; } CVector CVector::operator+ (CVector param) { CVector temp; temp.x = x + param.x; temp.y = y + param.y; cout << "operator+: " << CVector::n << endl; return (temp); } CVector& CVector::operator= (const CVector& param) { x=param.x; y=param.y; cout << "operator=: " << CVector::n << endl; return *this; } int main () { CVector a (3,1); CVector b (1,2); CVector c; cout << "Dichiarazioni variabili locali: " << CVector::n << endl; c = a + b; cout << a.x << "," << a.y <<endl; cout << b.x << "," << b.y <<endl; cout << c.x << "," << c.y <<endl; cout << "Fine: " << CVector::n << endl; return 0; } Codice:
id: 0 + x: 3 y: 1 id: 1 + x: 1 y: 2 id: 2 + Dichiarazioni variabili locali: 3 Memberwise initialization id: 3 + x: 1 y: 2 id: 4 + operator+: 5 operator=: 5 id: 4 - x: 4 y: 3 id: 3 - x: 1 y: 2 3,1 1,2 4,3 Fine: 3 id: 2 - x: 4 y: 3 id: 1 - x: 1 y: 2 id: 0 - x: 3 y: 1 Process returned 0 (0x0) execution time : 0.029 s Press any key to continue. |
27-12-2009, 18:01 | #6 |
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
Dopo ulteriori test e ricerche su internet credo di aver capito tutto, sono giunto a due conclusioni:
- Il fatto che nella funzione + temp non venga ricopiato in un oggetto di ritorno automatico e quindi non venga richiamato il costruttore di inizializzazione di default è dovuto ad un'ottimizzazione del compilatore: invece di creare inutilmente due oggetti usa direttamente temp come se fosse l'oggetto di ritorno. - Quando una funzione torna un oggetto questo viene utilizzato nell'operazione/funzione/qualsiasicosa in cui la chiamata era contenuta e poi viene distrutto. Penso che la distruzione del parametro/parametri venga effettuata insieme per ragioni di ottimizzazione. Spero che questo thread possa essere utile a tutti. Se ho scritto cose sbagliate spero che mi correggerete. |
27-12-2009, 23:12 | #7 | |
Senior Member
Iscritto dal: Oct 2005
Messaggi: 3305
|
Quote:
Per prima cosa non sono funzioni ma metodi. Nel caso di passaggio per copia l'oggetto viene distrutto al termine dell'istruzione che ha invocato il metodo. Se ritorni un riferimento ovviamente non puoi ritornare un oggetto locale perchè questo verrebbe distrutto al momento dell'uscita dal metodo, con il risultato di avere un riferimento non valido. Per questo l'operatore + ritorna una copia dell'oggetto temp definito localmente, al contrario l'operatore di assegnamento ritornando un *this può ritornare un riferimento in quanto this ha uno scope maggiore rispetto all'istruzione di assegnamento. Nel futuro standard è stata definita la move semantics e gli rvalue reference identificati dalla sintassi && per cui puoi ritornare un riferimento ad una variabile locale. Secondo me però hai sbagliato l'operatore +. Hai ridefinito l'operatore unario + (per intendersi l'operatore segno positivo), non l'operatore somma. L'operatore somma prende 2 oggetti di tipo CVector e ritorna un nuovo oggetto CVector. Ed eventualmente l'operatore unario doveva avere questa firma: Codice:
CVector CVector::operator+ (const CVector & param) |
|
28-12-2009, 02:08 | #8 | ||||
Senior Member
Iscritto dal: Nov 2005
Messaggi: 2745
|
Grazie mille per la risposta.
Quote:
Codice:
CVector& CVector::operator= (const CVector& param); Quote:
Quote:
Quote:
|
||||
Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 15:43.