Problème conceptuel de pointeur

Bonjour,
Je débute en c++ et je me trouve confronté à un problème de pointeur ... :roll:
Grosso modo en pseudo code :

Code:

---

1 2 3 4 5 6 7 8

Pour chaque element d'un vecteur : Objet o = vector.back(); Objet * t = transform( & o ); if( t ) cout << t ; delete t; t = nullptr; Fin pour

---

Sauf que je récupére un message d'erreur qui me dit que le programme supprime 2 fois le même objet ... ce qui est vrai.
Mes besoins : récupérer un objet venant d'un vecteur et le passer à une fonction en pointeur pour le transformer.
J'ai essayé avec un "shared_ptr" avec le meme résultat.
Qu'est ce que ça vaut de ne pas faire

Code:

---

delete t

---

vu que l'objet crée en amont sera détruit par le programme ?
Ou auriez vous une solution ?
Merci,

Ce serait bien d'avoir du vrai code (réduit à l'essentiel) plutôt que du pseudo code. En particulier, elle fait quoi ta fonction transform ?

La fonction transform prend en argument un pointeur sur l'objet, transforme éventuellement cet objet ou renvoi un pointeur null.

Code:

---

1 2 3 4 5 6

Objet* MyObjet::transform( Objet * o ) { if ( o.getName().compare( "ok") == 0 ) return o; return nullptr; }

---

Je conçois que le pseudo code ne soit pas terrible mais le code l'est encore plus ...

Bah c'est plutôt clair : tu fais un delete sur un objet qui n'est même pas alloué dynamiquement. :calim2:
Ta fonction transform retourne le pointeur passé en paramètre, dans ton pseudo-code c'est en rien un objet dynamique.

Et plutôt que de se faire des nœuds au cerveau avec ces pointeurs nus tout moisi, pensez à utiliser des pointeurs intelligents qui vous forcent à vous poser les bonnes questions (qui est propriétaire de l'objet, il est partageable ou pas, etc...).

J'ai nettoyé le code, isolé les élements pour arriver à ça :

Header :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#ifndef VEHICULE_INCLUDED #define VEHICULE_INCLUDED   #include <vector>   class Vehicule { public: Vehicule(); Vehicule(std::string n, int i); ~Vehicule(); std::string getName(); void setName(std::string n); int getRoue(); void setRoue(int i); Vehicule* transform( Vehicule &other );   private: std::string name; int roue; };   #endif //VEHICULE_INCLUDED

---

Definition :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <string> #include "Vehicule.h"   using namespace std;     Vehicule::Vehicule(){} Vehicule::Vehicule(string n, int i) : name(n), roue(i){} Vehicule::~Vehicule(){} string Vehicule::getName(){ return name ;} void Vehicule::setName(string n){ name = n;} int Vehicule::getRoue(){ return roue ;} void Vehicule::setRoue(int i) {roue = i ;}

---

Main :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <iostream> #include <memory> #include <string> #include "Vehicule.h"   using namespace std;     shared_ptr<Vehicule> transform_shared( shared_ptr<Vehicule> other ) { if( other -> getName().compare( "ok" ) == 0 ) return other; return nullptr; } Vehicule* transform( Vehicule* other ) { if( other -> getName().compare( "ok" ) == 0 ) return other; return nullptr; }

---

Ce code utilise des pointeurs bruts :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int main() {   Vehicule v1( "ok", 4 ); Vehicule* v2 = new Vehicule; v2 = &v1;   v2 = transform( v2 );   if (v2) cout << "V2 " << v2 -> getName() << endl; cout << "V1 " << v1.getName() << endl; //delete v2; -> Fonctionne v2 = nullptr;   cout << "END" << endl; }

---

Et avec une valeur "ok", la fonction transforme renvoi donc le meme pointeur et l'objet est supprimé 2 fois par le programme : quand le v1 est supprimé automatiquement et quand v2 est "delete" il l'est également. Par contre cela fonctionne si on ne fait pas de "delete" sur le pointeur brut. Il n'y a pas de problème de fuite mémoire, j'ai testé une autre version avec 1 Go de données et j'ai rien vu passé dans l'utilisation de la RAM. Mais comme j'ai lu quelque part qu'un pointeur brut non supprime c'est mal, avec un shared_ptr cela fonctionne très bien :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int main() {   Vehicule v1( "ok", 4 ); shared_ptr<Vehicule> v2( new Vehicule );   v2 = transform( v2 );   if (v2) cout << "V2 " << v2 -> getName() << endl; cout << "V1 " << v1.getName() << endl;     cout << "END" << endl; }

---

Merci, j'ai pu avancé dans ma réflexion grâce à vos remarques

Citation:

---

Envoyé par The_GuiGui

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <iostream> #include <memory> #include <string> #include "Vehicule.h"   using namespace std;     shared_ptr<Vehicule> transform_shared( shared_ptr<Vehicule> other ) { if( other -> getName().compare( "ok" ) == 0 ) return other; return nullptr; } Vehicule* transform( Vehicule* other ) { if( other -> getName().compare( "ok" ) == 0 ) return other; return nullptr; }

---

Ce code utilise des pointeurs bruts :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int main() {   Vehicule v1( "ok", 4 ); Vehicule* v2 = new Vehicule; v2 = &v1;   v2 = transform( v2 );   if (v2) cout << "V2 " << v2 -> getName() << endl; cout << "V1 " << v1.getName() << endl; //delete v2; -> Fonctionne v2 = nullptr;   cout << "END" << endl; }

---

---

Ce code est tout autant faux en plus d'avoir une fuite mémoire. Si tu fais ton delete, que t'as beau commenté "fonctionne", tu vas delete... v1 qui n'est pas alloué dynamiquement.

Oui, c'est ce que j'ai voulu dire.
Si on fait le delete, on supprime v1 et ça plante parce que le programme le supprime, si on le fait pas v1 est deleter automatiquement et cela fonctionne