overloader un opérateur

Salut tout le monde!
Comme le nom de l'intitulé le dit je voudrais overloader un opérateur(le + pour être plus précis. Je travaille avec des listes chainées que j'ai codé auparavant(toutes mes fonctions fonctionnent très bien j'ai fait plein de test). Il s'agit d'un projet scolaire et voici la consigne pour l'overloading de l'opérateur :
"L3 = L1 + L2: Creates a new linked list, called L3, which consists of L1
and L2."
Ma fonction est censé me créer une nouvelle liste chainé qui contiendra tout les maillons de L1 et L2 à la suite. (j'ai overloader =avant bien entendu....), donc je me concentre sur L1+L2;

Code:

---

1 2 3 4 5 6 7 8

SpecialLinkedList& SpecialLinkedList::operator+(SpecialLinkedList& Source) { SpecialLinkedList New; New.addAll(this); //permet de rajouter tout les maillons de this dans New New.addAll(&Source); //permet de rajouter tout les maillons de Source dans New. return New; }

---

Dans mon cas le this est L1 et Source est L2;
Je sais que je retourne un SpecialLinkedList et que mon prototype dit que je doit renvoyer un SpecialLinkedList&, donc j'ai une incompatibilité...Mon erreur ne doit pas venir que de là(je suppose!). le compilateur me sort un avertissement qui me crash le programme à l'éxecution.Mon probleme est que je n'arrive pas à retourner un objet créer dans ma fonction...Si je lis ma liste chainée juste avant de faire le return, j'ai le résultat souhaité!
je suis ouvert à tout conseil...peut être il y a quelque chose que j'ai mal compris...
Je vous remercie par avance de votre aide :D

Là tu renvoies une référence sur un objet qui va être détruit dès la fin de la fonction, normal que ça crash. Lorsque tu renvoies un nouvel objet, qui n'existe pas en dehors de la fonction, il faut le renvoyer par valeur et non par référence. Ainsi il sera recopié et l'original pourra être détruit sans problème.

Pour ce genre de truc il serait plus intéressant d'avoir des listes immutables et de faire du partage implicite.

Si j'ai bien compris Laurent Gomila, tu me dis de mettre mon prototype comme tel:

Code:

---

1 2 3 4 5 6 7 8

SpecialLinkedList SpecialLinkedList::operator+(SpecialLinkedList& Source) { SpecialLinkedList New; New.addAll(this); New.addAll(&Source); New.Display(); return New; }

---

je n'ai plus aucun avertissement, mais lors de l'éxecution au moment d'afficher le résultat il commence à m'afficher comme premier maillon une adresse mémoire(contrairement à un simple entier...) et ensuite est incapable de lire la suite ce qui le fait crasher!
Ensuite:

Code:

---

1 2 3 4 5 6 7 8

SpecialLinkedList& SpecialLinkedList::operator+(SpecialLinkedList& Source) { SpecialLinkedList* New=new SpecialLinkedList; New->addAll(this); New->addAll(&Source); New->Display(); return New; }

---

Ce que j'avais penser aussi était de déclarer ma nouvelle liste chainée dynamiquement comme cela elle ne se serait pas effacer, mais mon problème est que je ne sais convertir "SpecialLinkedList *" en "const SpecialLinkedList &". J'ai lus dans la FAQ et dans les tutoriels que le retour par référence est comme avec les pointeurs mais que cela n'en est pas...Dans mon dernier cas comme retourner ma liste chainé par référénce?

loufoque, je ne comprend pas de quoi tu parle, je cherche des infos sur ce que tu m'as dit mais je ne trouve pas....comme je l'ai dit, il m'est imposé d'utiliser mes propres listes chainées, impossible d'utiliser la STL par exemple...

Merci pour votre aide!

Citation:

---

Code:

---

1 2 3 4 5 6 7 8

SpecialLinkedList& SpecialLinkedList::operator+(SpecialLinkedList& Source) { SpecialLinkedList* New=new SpecialLinkedList; New->addAll(this); New->addAll(&Source); New->Display(); return New; }

---

Ce que j'avais penser aussi était de déclarer ma nouvelle liste chainée dynamiquement comme cela elle ne se serait pas effacer, mais mon problème est que je ne sais convertir "SpecialLinkedList *" en "const SpecialLinkedList &". J'ai lus dans la FAQ et dans les tutoriels que le retour par référence est comme avec les pointeurs mais que cela n'en est pas...Dans mon dernier cas comme retourner ma liste chainé par référénce?

---

Tu peux toujours terminer par un

Code:

---

return *New;

---

mais alors la problématique devient la suivante: comment bien libérer la mémoire allouée par ton "new SpecialLinkedList" qq part dans ton programme... ça sera peut-être pas si facile. Donc à mon avis il vaut mieux faire un retour soit par valeur, soit par pointeur.

Il n'y a pas de problème pour libérer la mémoire par la suite car mon destructeur s'occupe de supprimer chaque maillon de ma liste chainée. Au pire j'ai créer une fonction qui le fait(mon destructeur l'appelle!).

Je te remercie beaucoup pour ton coup de pouce Biozic, en changeant mon retour effectivement le problème s'est résolu!!Du beau travail, ni erreur ni avertissement!Cela ma permet de comprendre un peu mieux le retour par référence!
Je met le code final pour si un jour une personne retombe sur mon post!

Code:

---

1 2 3 4 5 6 7

SpecialLinkedList& SpecialLinkedList::operator+(SpecialLinkedList& Source) { SpecialLinkedList* New=new SpecialLinkedList; New->addAll(this);//ajoute tout les maillons de this(L1) dans ma nouvelle liste chainée New->addAll(&Source);//ajoute tout les maillons de Source(L2) à la suite dans ma nouvelle liste chainée return *New; }

---

Je remercie tout ceux qui m'ont aidé!et vive developpez.net!

Citation:

---

Il n'y a pas de problème pour libérer la mémoire par la suite car mon destructeur s'occupe de supprimer chaque maillon de ma liste chainée. Au pire j'ai créer une fonction qui le fait(mon destructeur l'appelle!).

---

Je ne sais pas de quel destructeur tu parles. Il est bien possible que ce destructeur libère chacun des maillons, mais es-tu sûr que ce destructeur sera lui-même appelé à un moment ou à un autre? Si tu penses à celui de New, j'ai bien peur qu'il ne soit jamais appelé si tu ne fais pas qq part un delete sur cet objet, non?

En fait ma solution était peut-être correcte du point de vue de la syntaxe, mais c'était certainement une mauvaise idée du point de vue de la conception.

En effet. En retournant une référence, on perd de vue que l'objet a été alloué dynamiquement et donc que la durée de vie de cet objet est entre nos mains.
Ceci n'est pas fait si l'on retourne un pointeur -> il y a aura une rigueur plus importante mise en place pour cantonner cette durée de vie à celle qu'on lui réserve.

Moralité, quand on surcharge operator+, il n'y a pas vraiment d'autre choix que de retourner par valeur. Désolé pour le piège! :oops:

Oui vous avez raison le destructor ne s'appelle pas pour mon objet alloué dynamiquement, mais je le detruit à la fin de mon main()....manuellement(sans jeu de mot...)
Par la suite la surcharge de l'operator- en a découlé de source!
Ton piège n'en était pas un...suffit de faire un peu attention!Et il me permet de garder l effet cascade...(L1+L2+L3 par exemple)