R�f�rence et delete

Bonjour,

j'obtiens une erreur dans le code suivant :

Code:

---

1 2 3 4 5 6 7

OPTRES* g_OptPty = NULL; ...   g_OptPty = &Option_Call(...);   delete g_OptPty

---

O� Option_Call est une fonction qui renvoie un OPTRES :

Code:

---

1 2 3 4 5 6 7 8 9

OPTRES Option_Call(double& _Under, double& _Strike, double& _RiskFreeRate, double& HistVol, double& Time) { OPTRES l_Res;   ....   return l_Res; }

---

Ce code compile, mais plante au delete. Je n'arrive pas � me convaincre du pourquoi le delete n'a pas sa place ici ; c'est donc que je ne comprend pas bien ce qui se passe : pourriez-vous m'�clairer ?

Autre chose, je souhaite que mon code soit aussi rapide que possible, et donc r�alise le moins de cr�ation/destructions d'objets et acc�s en �criture (d'o� le passage par r�f�rences). J'ai donc choisi de d�clarer g_OptPty comme un pointeur dans le main pour ne pas allouer un objet inutilement, mais en �change, j'aurais un acc�s m�moire � chaque fois que j'acc�derai � un membre.
De m�me, la fonction Option_Call cr�e un objet OPTRES � l'int�rieur, puis le renvoie. Mais est-ce la meilleure solution ? Ne devrais-je pas passer un argument suppl�mentaire (genre pOut), par r�f�rence, et travailler dessus ?

Bref, dans l'optique adopt�e, quelles sont les techniques utilis�es en pratique ? Que feriez-vous ?

Merci

Cordialement

Il te faut cr�er un objet dynamiquement :

Code:

---

1 2 3 4 5 6

OPTRES* g_OptPty = NULL; ...   g_OptPty = new OPTRES(Option_Call(...));   delete g_OptPty

---

Ou alors, c'est ta fonction qui doit renvoyer un objet cr�� dynamiquement (pas toujours tr�s prudent, dans la mesure o� tu d�couples le new et le delete) :

Code:

---

1 2 3 4 5 6 7 8

OPTRES* Option_Call(double& _Under, double& _Strike, double& _RiskFreeRate, double& HistVol, double& Time) { OPTRES* l_Res = new OPTRES;   ....   return l_Res; }

---

Mais sinon : as-tu vraiment besoin d'un pointeur, ou un objet simple est-il suffisant ? Que fais ta fonction ? Est-ce-qu'elle renvoie un objet en fonction d'un certain nombre de param�tres externe, ou est-ce-qu'elle se contente de plagier le travail du constructeur ?

Pourquoi �a plante : quand tu entres dans ta fonction, tu cr�es un objet. Quand tu sors de ta fonction, une copie de cet objet est cr��e et renvoy�e, puis le premier objet est d�truit. Puis le pointeur re�oit l'adresse de l'objet renvoy�, gr�ce au '&' devant l'appel � ta fonction, puis cet objet est d�truit. Moralit�, quand tu arrives au delete, le pointeur pointe sur un objet qui a �t� cr�� sur la pile, et qui n'existe plus => erreur de segmentation. Enfin, je ne suis pas � 100% s�r des �tapes, de toutes les cr�ations, mais l'id�e g�n�rale c'est qu'� la fin tu fais un delete sur un pointeur invalide.

A ta place je cr�erais d'abord l'objet, puis le passerais par r�f�rence � la fonction:

Code:

---

1 2 3 4

OPTRES g_OptPty; ...   Option_Call(g_OptPty);

---

Code:

---

1 2 3 4 5 6

void Option_Call(/*paramètres habituels, */ OPTRES& myOPTRES) { // utilisation de myOPTRES, exemple: myOPTRES.faisCeci(); myOPTRES.faisCela(); }

---

Dans ton main, � la sortie de la fonction, celle-ci aura bien modifi� ton objet OPTRES. Tu n'as donc qu'un constructeur, et pas la peine de s'emb�ter avec des pointeurs ou de l'allocation dynamique de m�moire.

Un compilateur avec les bons warnings activ�s t'aurait d'ailleurs pr�venu que tu prenais l'adresse d'un objet temporaire (autrement dit, que tu affectais � ton pointeur une adresse qui serait invalide d�s la fin de l'affectation).

Merci � vous !

En fait, le compilo (VC++) me le dit bien... quand je met le niveau des warnings � 4 (il �tait � 3).

Merci encore

Cordialement

Comme on parle un peu optimisations, j'aurais une question suppl�mentaire.
Imaginons que j'ai une formule dans laquelle appara�t plusieurs fois le produit a*b. A partir de combien de fois il devient rentable de d�clarer une variable contenant le r�sultat a*b ?

Pour l'instant, j'ai fait ce remplacement d�s qu'un tel produit appara�t deux fois. Par exemple, avec le code suivant :

Code:

---

1 2	const double stime = sqrt(_Time);

---

Mais si j'�crit

Code:

---

1 2	const double& stime = sqrt(_Time);

---

Ca fonctionne aussi. Le code est un peu moins lisible, mais gagne-t-on vraiment du temps � utiliser la r�f�rence ? Et est-ce que �a ne risque pas de planter ? Je pense que, pour le coup, ici la r�f�rence est inutile. Qu'en pensez-vous ?

Merci

Cordialement

Il me semble que c'est VS qui permet de faire �a mais que c'est pas standard... VS te permet de prolonger la vie d'une donn�e temporaire jusqu'� la fin du scope o� se trouve la r�f�rence.
Mais tu devrais pas compter dessus.

Ok merci