portée d'une instance retournée par une fonction

Bonjour à tous.

Il y'a un truc que je pige pas trop en C++.. Ne fait pas attention à la syntaxe, c'est la theorie qui m'interresse


Imaginons une classe "voiture".

Si dans une fonction "duplicate" je cherche à retourner un nouvel objet "voiture" je ne sais pas comment je doit m'y prendre et ce que cela implique. Par ex :

Code:

---

1 2 3 4 5

voiture duplicate(){ voiture v; return v; }

---

ou

Code:

---

1 2 3 4 5 6

voiture* duplicate(){ voiture v,*ptr; ptr=&v; return ptr; }

---

Ce que je ne pige pas d'une part, c'est la portée. ici "v" est declaré et initialisé dans ma fonction duplicate. Donc normalement, une fois terminé, la mémoire devrait etre liberé. Dans ce cas, ces 2 principes sont-ils faux vue que je peut pas reutiliser le pointeur retourné ?

En fait ce que je cherche à faire c'est declarer et initialiser un nouvel objet "v" en appellant la fonction duplicate();

dans le genre :

Code:

---

1 2	voiture v=duplicate();

---

Mais cette ecriture est pas bonne. Si je passe par un pointeur est-ce que je suis obligé de faire un delete pour eviter une fuite de mémoire ?

Je sais que je suis pas clair, j'ai bien besoin d'une chtite explication

Merci !

Code:

---

1 2 3 4 5 6 7 8 9 10 11

duplicate(objet) { return objet; }   ...     voiture v=duplicate(objet_que_tu_veux_dupliquer);

---

Je ne crois pas que c'est ça que tu cherches à faire...

Code:

---

1 2 3 4

voiture duplicate(){ voiture v; return v; }

---

Valable, ce qui est retourné n'est pas l'objet v mais une copie de l'objet v avant sa destruction en sortie de la fonction;

Code:

---

1 2 3 4 5

voiture* duplicate(){ voiture v,*ptr; ptr=&v; return ptr; }

---

Faux, tu retourne l'adresse d'un objet qui est détruit en sortie de la fonction donc qui n'existe plus. Ou alors, il faut l'allouer dynamiquement (new). Même chose si le retour est fait par reférence sur v.
Normalement, pour ce problème, tu devrais écrire un constructeur par copie (si le constructeur par copie par défaut ne peut suffire) et surcharger l'opérateur = ce qui est plus dans la logique C++

Bonjour et merci beaucoup de la reponse rapide :P

ok donc je vais rester sur :

Code:

---

1 2 3 4 5

voiture duplicate(){ voiture v; return v; }

---

Mais est-ce que la copie n'est pas gourmande en ressource cpu ?

Du coup comment est-ce que je peux l'initialiser depuis un autre scope ? un truc du genre ? par ex :

Code:

---

1 2	voiture v=duplicate();

---

Mais dans ce cas je ne peux pas le creer dynamiquement ! non ?

Citation:

---

Mais est-ce que la copie n'est pas gourmande en ressource cpu ?

---

Tout dépend de la taille de l'objet puisqu'un objet temporaire va être créé par copie, retourné par la fonction, copié dans sa destination puis détruit. Ce n'est pas effectivement économique

Citation:

---

Du coup comment est-ce que je peux l'initialiser depuis un autre scope ? un truc du genre ? par ex :

---

Je ne comprends pas ce que tu veux dire
Tu peux allouer dynamiquement dans ta fonction duplicate et renvoyer un pointeur mais il faut alors stocker le pointeur renvoyé par la fonction de façon à pouvoir faire le delete. C'est plus délicat à gérer.
Réfléchis à la possibilité d'utiliser un constructeur par copie.

Arf.. je patauge completement la.

Bon j'ai fait simple dans le cas de la voiture, mais en fait j'utilise un opperateur + qui est censé me retourner un nouvel objet.

j'ai un truc du genre :

Code:

---

1 2 3 4 5 6

voiture voiture::operator + (voiture *v){ voiture nv; nv.x=x+v->x; // x est un int return v; }

---

Ensuite j'ai :

Code:

---

1 2 3 4

voiture vA,vB; voiture vC=vA+vB; printf("%d\n",vC.x);

---

Je voulais savoir si pour vous cette ecriture est juste. Chez moi avec mon code complet (qui fait plus q'une simple addition) je me retrouve avec une Erreur de segmentation :evil: .

Alors ptet que c'est le reste du code qui deconne.. Cette erreur semble survenir l'ors de l'appel du destructeur de la classe voiture. Dans le destructeur je fait juste un delete d'un tableau créé dynamiquement.

Bref je rame.

Ca ressemble fort à une classe copiable mal implémentée.

Pour rappel, toute classe copiable doit avoir :

• Un constructeur par défaut
• Un constructeur par copie
• Un destructeur
• Un opérateur d'affectation

Ensuite il faut que ces 4 là soient correctement implémentés, ce qui est rarement le cas.

Donc montre les nous, on pourra t'en dire plus.

A noter que si ta classe ne manipule pas de ressource, alors les versions générées par le compilo seront suffisantes, tu n'auras pas besoin d'écrire les 4 fonctions citées plus haut. Et si tu dois manipuler une ressource (par exemple un pointeur), alors tu peux l'envelopper dans quelque chose de copiable et sûr, voir par exemple les pointeurs intelligents.

Code:

---

1 2 3 4 5

voiture voiture::operator + (voiture *v){ voiture nv; nv.x=x+v->x; // x est un int return v; }

---

Un opérateur + doit être une fonction externe à la classe (this ne joue pas de rôle particulier) éventuellement déclarée friend du genre

Code:

---

1 2 3 4 5 6

voiture operator+( const voiture &a, const voiture &b) { voiture nv; nv.x=a.x+b.x; // x est un int return v; }

---

Dans ton écriture, avec

Code:

---

vC=vA+vB;

---

ceci correspond à voiture

Code:

---

vC=vA.operator+(vB);

---

or vB n'est pas un pointeur sur voiture. Tu n'as pas eu de warning ?

Bonjour loulou24 :-)

Alors je n'ai pas de constructeur par copie. Est-ce obligatoire ?

Oubliez ce que je vous ai mis plus haut, c'etait pour simplifier. Voila exactement ce que je fait : Il s'agit d'une classe String. (oui je sais y'en a deja des toutes faites, mais c'est un entrainement pour moi de le faire moi même :) ).

Le constructeur actuel de ma classe initialise des valeurs :

Code:

---

1 2 3 4 5

size=100; length=0; value=new char[size+1]; value[0]=0;

---

Le tableau "value" est dynamique car il est possible que sa taille augmente au cours du temps. Mais la on en est pas la donc c'est pas traité.

Le destructeur lui :

Code:

---

1 2	delete [] value;

---

Dans ce cas, l'operateur + doit generer un nouveau String dont le tableau de char "value" est une concatenation des tableaux des 2 operandes.

J'ai des fonctions membres : setValue(char *) et addValue(char *) qui fonctionne apparament tres bien.

Mon operateur + fait alors exactement ceci :

Code:

---

1 2 3 4 5 6 7

String String::operator + (char *s){ String str; str.setValue(value); // on y met la valeur actuelle str.addValue(s); // on y ajoute l'operande de droite return str; }

---

Au final pour faire mon test je fait :

Code:

---

1 2 3 4 5

String A; A="salut"; String C=A+" toi"; printf("%s\n",C.value);

---

et j'obtien :

Citation:

---

salut toi
compile.sh: line 2: 29980 Erreur de segmentation ...

---

Notez que cela fonctione tres bien quand je fait :

Code:

---

1 2 3 4 5 6 7

String A; A="salut"; String C; C.setValue(A); C.addValue(" toi"); printf("%s\n",C.value);

---

J'ai bien en sortie :

Citation:

---

salut toi

---

C'est pour cela que je pige pas tres bien pourquoi cela ne marche pas. quand j'appelle setValue et addValue moi même cela marche tres bien. Mais quand je cherche à passer par l'operateur ça marche pas 8O.

Voila a tous les coup j'ai pas pensé à un truc bête.

Merci en tous cas à celui qui lira ce post et m'eclairera sur le prob.

Arf je pense avoir compris ce qui se passe. dites moi si c'est bien ça :

La copie temporaire de l'objet copie tous y compris le pointeur "value". Donc cette copie de pointeur pointe toujours vers le même tableau en mémoire "value". du coup l'appel du destructeur de l'objet temporaire detruit aussi celui de l'operande. Au final un appel successif sur un objet deja detruit me met une erreur de segmentation.

Est-ce cela ?

C'est ca . Tu es dans le cas signalé par Loulou24 où tu as l'obligation d'écrire un constructeur par copie où la chaîne elle-même est copiée.

Et bien merci beaucoup à tous, cela devient limpide pour moi maintenant.

@+