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