Je vais essayer de faire simple:
 
j ai un object Alpha qui pour contient un tableau
 
je veux ecrire la fonction: Alpha& operator+(Alpha& operande);
 
le problem est le suivant.
 
si le resultat est une variable local de la fonction operator+, le  destructeur est appliqué dessus apres return, et adieu mon tableau.
 
ce que je faisais c etait de creer un objet alpha avec new et de retourner *resultat.
 
Ca marche, le seul problem c est que pour liberer la memoire ensuite je dois faire delete. et comme y a plein de calculs intermediaires je n ai pas tous les pointeurs, et donc ma mémoire explose en 10 seconde.
 
En gros je voudrais retourne un objet qui n ait pas ete instancie avec new, mais que le destructeur ne passe pas dessus...
 
...
 
 

???
 
deja :
 

 
et a marche trés bien, le tableau est renvoyé correctement.

ben justement ça je l'utilise, ça marche,
 
mais je crois que dans la théorie ça ne devrait pas marcher ...
 
apres y'a aussi le  

à condition d'avoir défini l'op de copie ...
 
bon là je crois que ça revient au meme mais c plus beau parfois ...
 
mais bon je suis pas trop clair la dessus ... si quelqu'un savait vraiment ce serait bien cool...

le constructeur de copie existe toujours sauf si tu l'as interdit (rendu privé par exemple)
 
quand tu fais un return il y a une copie sauf si ton compilateur fait l'optimisation que lui permet le standard (vc ne la fait pas par exemple)
 
donc la tu fait une copie en plus encore inutile...

oui l'op de copie existe partout, c juste qu'un warning "as tu defini ton op de copie si ta classe en a besoin ??" c allumé au moment ou j'ai ecrit le post ...
 
c sur la destination de la copie que j'ai un doute ... il copie sur la pile, et il récupère apres non ?
 
je croyais (enfin j'ai du lire quelque part) que si tu renvoyer pas comme ça, le return marchait, mais que en gros c'était du bol ... parce que si ton objet était trop gros, tu avais une bonne chance de te prendre un core file ... pask justement il le copiait pas sur la pile ...
 
bon c clair, j'ai toujours fait le return tout con, mais j'avais quand meme dans la tete cette histoire ...
 
tu me confirme qu'en faisant le return tout con, ça marche à tout coup ?
 
PS : au fait c quoi l'optimisation que permet le standard ?

éviter la recopie de la valeur de retour dans le contexte appelant

Ok je vais essayer,
 
mais juste pour etre sur...
 
Pourquoi le code suivant marche pas ??
 

 
En général mon resultat est detruit est je me retrouve avec une reference vers rien...

y a quoi dans ta classe Alpha ?
de quelle reference parles tu ?
 
de plus, les opérateurs binaires symmétriques sont à céclarer en fonctions globales et non pas en méthodes.

pourquoi ca ?  
il me semblait que le seul a declarer en global (parce qu'on peut pas faire autrement) c'est ">>"...

parce que c'est symétrique et binaire justement

En gros:
 

 
et avec ton code aussi... Avant le return mon tableau contient le bon resultat. Et apres le return mon tableau est vide (plus precisemnt la memoire a ete ecrasee.)
 
j ai verifie, le pointeur tableau pointe toujours sur la meme addresse memoire.
 
Enfin mon destructeur:  

 
mon sentiment c est qu apres return result, le destructeur est applique sur result. les valeurs du pointeur et int, double & co etant passes en copie, ils survivent, par contre mon tableau prend cher...
 
merci

oh du C ...
 
non mais ça va bien ou quoi ?

 
bon visiblement j ai fait quelque chose qui fallait pas ...
je suppose que je dois utiliser new and delete ?
 
je pensais que c etait strictement equivalent

 
tu penses mal ^^
 
new et delete gére aussi les appels au constructeur/destructeur lorsque tu instancie un objet.
ce qu ne font pas malloc/free

t'es marrant toi ... tu lui dit d'écrire des constructeurs/destructeur et d'utiliser malloc/free qui ne font que de l'allocation alors que les operateurs new/delete eux font en plus la construction/destruction.
 
comprends en quoi ton code est ridicule

si le message est : "ne pas créer d object avec malloc", çà tombe bien parceque çà n a jamais ete ni le cas ni mon intension.
 
Je n utilise malloc et free que pour mes tableaux afin de pourvoir utiliser realloc quand j ai un tableau qui change de taille.

t'as essaye ca:
Alpha Alpha::operator+(const Alpha& op 2 )  
  {  
       Alpha result = new Alpha();  
     
      // tes trucs  
     
      return result;  
  }
 
??

question:
 
1 object avec 2 references.
 
si j appelle delete sur une des references, est ce que mon object est detruit, ou faut il qu il ne reste plus qu une reference pour qu il puisse etre detruit ?

 
 
Putain, ca vaut presque FORTUNE ca

 
std::vector est ton ami.

ui il sera detruit, et ta deuxieme ref pointera sur n'importe quoi...

 
ca ca marche... mais il y a un hic:
 
qui dit new dit delete...
 
hors si je fais (a+a)+a
 
le resultat de (a+a) n est jamais detruit...
 
a moins que je ne decide que + detruit les operandes... c'est bourain, peu ellegant... mais çà va sans doute etre ce que je vais finallement faire.
 
dans ce cas il faut aussi que fasse:
 
(a.copie()+a.copie())+a.copie()

 
mais arreterquoi !
 
 
Alpha a = new Alpha(); <<-- n'importequoi.
 
on a deja donner une solution propre qui marche.

tu vois qu'il me le faut mon spoiler-powa

 
Mais j'en veut un aussi  

 
Ca, ça ne marche qu'avec un compteur de références. Sinon, tu dois gérer ça toi-même. delete() détruit ton objet même s'il reste des références qui pointent dessus.

 
ca me fait plaisir d'ecrire des anneries

 
et ben