[C++] visibilité d'une variable

[serik]

Salut,

Ma question est simple, soit le bout de code suivant:

TypeDeVariable& f(){
TypeDeVariable tdv();
return tdv;
}

La variable déclarée est-elle détruite à la fin de la fonction? Si "non", si la fonction ne renvoyait rien, la variable serait-elle détruite? Le cas de la redéfinition d'un opérateur ("+" par exemple) influe t-il sur la destruction des variables construites ainsi?

Merci.

PS: j'oubliais : la variable est-elle crée toujours sur le tas ou en pile?

[serik]

Autre question : est-il possible de définir une fonction qui renvoie une référence sur un objet sans que celui soit issu d'une copie, tout ça dans une fonction non-membre. Car si j'ai bien compris, seul le retour de *this ne déclenche pas une construction par copie.

Vector3D& trick(){
Vector3D a(2,2,2);
return a; // déclenche la copie de a
}


Vector3D& trick(){
Vector3D * a = new Vector3D(2,2,2);
return *a; // déclenche la copie de a et sa perte (memory leak)

}

Comment faire pour que ce soit la référence de a qui soit renvoyé et non sa copie?

[16ar]

Salut,

Ma question est simple, soit le bout de code suivant:

TypeDeVariable& f(){
TypeDeVariable tdv();
return tdv;
}

La variable déclarée est-elle détruite à la fin de la fonction? Si "non", si la fonction ne renvoyait rien, la variable serait-elle détruite? Le cas de la redéfinition d'un opérateur ("+" par exemple) influe t-il sur la destruction des variables construites ainsi?

Merci.

PS: j'oubliais : la variable est-elle crée toujours sur le tas ou en pile?

Ca c'est une bonne question !

Pour une fonction classique, la variable devrait être détruite. Or ta fonction renvoie la référence...

Donc la perso, je serai pour dire que ca créé une copie et que ca pointe la référence vers cette copie.

Pour les variables sur le tas ou la pile, d'apres ce que je sais, les variables de base sont dans la pile, mais a partir du moment ou ce sont des classes personnalisés, ca sera sur le tas. Il me semble que les struct basées sur des variables de bases, c'est aussi stocké sur la pile.

Autre question : est-il possible de définir une fonction qui renvoie une référence sur un objet sans que celui soit issu d'une copie, tout ça dans une fonction non-membre. Car si j'ai bien compris, seul le retour de *this ne déclenche pas une construction par copie.

Vector3D& trick(){
Vector3D a(2,2,2);
return a; // déclenche la copie de a
}


Vector3D& trick(){
Vector3D * a = new Vector3D(2,2,2);
return *a; // déclenche la copie de a et sa perte (memory leak)

}

Comment faire pour que ce soit la référence de a qui soit renvoyé et non sa copie?

a part faire la méthode de porcos en déclarant le pointeur en dehors de la fonction, dans ta classe, je ne vois pas. Vu les explications données.

Mais sinon, deja, l'utilisation de shared_ptr devrait t'eviter quelques merdes au niveau des memory leak etc. (je parle de shared_ptr de la librairie boost, pas les ref_ptr de base de la librairie standard C++, car y'a des soucis avec eux il me semble, et ils sont moins souples.)

[lorinc]

Quel est l'intérêt de travailler avec des références, si c'est pour avoir des copies ? D'ailleurs à quel espace mémoire est faite la copie ? dans le tas ?

À mon avis, tdv est un espace réservé en Data, rempli correctement quand tu appelle ta méthode (à l'aide du constructeur) et la ref est celle de cet zone de Data. Bref, on peut considérer la variable comme détruite.

[serik]

Alors d'après ce que j'ai compris (hors optimisation qui peuvent pousser à ne pas copier une variable):

TypeDeVariable f(){
TypeDeVariable x();
return x; // renvoie une copie (hors optimisation, car le compilo est capable avec uniquement ça de ne pas renvoyer une copie de l'objet et de détruire x
}

TypeDeVariable& Classe::operator+=(TDV z){
return *this; // ne fait pas de copie
}

TypeDeVariable& f(){
TypeDeVariable x();
return x; // marche mais provoque un warning, copie la variable
}

En fait, si j'ai bien compris, renvoyer une référence ne doit servir que dans une supplantation d'opérateur, non?

De même pour ma classe Vector3D, si on a trois Vector x, y, z, il est moins couteux de faire :

x+=y;

x+=z;

Que

x += y+z;

Car y+z va créer une nouvelle variable, qui sera ajoutée à x pour être détruite ensuite...