BESOIN D'AIDE : PB AVEC POINTEURS, CONSTRUCTEUR ET DESTRUCTEUR [Résolu]

Messages postés
57
Date d'inscription
mardi 11 mars 2003
Dernière intervention
24 avril 2013
- 12 juil. 2010 à 16:38 - Dernière réponse :
Messages postés
57
Date d'inscription
mardi 11 mars 2003
Dernière intervention
24 avril 2013
- 23 juil. 2010 à 18:50
Salut à tous,

j'ai un soucis avec des pointeurs, des constructeurs et des destructeurs.... si quelqu'un peut me donner un tit coup de main...

Donc en gros, j'ai un première classe CEmetteur qui contient :
- un string
- un pointeur sur une structure Rating (qui contient trois arguments, deux string et un double)...
L'allocation de mémoire de ce pointeur sur Rating est réalisée dans le constructeur...
Je définis donc un destructeur contenant un simple delete _rating (qui est le nom de mon pointeur)

Ensuite j'ai une seconde classe CExpoEmetteur qui contient entre autres :
- quelques attributs privés de type double, string, ...
- un pointeur sur un objet CEmetteur
1 - le constructeur prend en argument un objet Emetteur, et j'y alloue de la mémoire, donc ca donne un truc du genre :
ExpoEmetteur(CEmetteur emetteur, autres arguments...) : _AutresArguments(autresArgument)
{
_emetteur = new CEmetteur(emetteur);
}
2 - J'ai ensuite créé un destructeur qui fait un delete de _emetteur...

Donc jusque là ca va, enfin je crois... mais j'ai le soucis suivant, dans une aute classe je manipule ces objets de la manière suivante :

CEmetteur emetteur(string argEmetteur, argStructRating1, argStructRating2, argStructRating3);
CExpoEmetteur *expoEmetteur = new CExpoEmetteur(emetteur, autres arguments...);

J'ai mis un pointeur, car je dois en créer un certain nombre que je place ensuite dans un vector.... enfin bref...

Donc mon soucis est le suivant, mon objet emetteur est bien créé, mon pointeur de CExpoEmetteur aussi... cependant au moment de la construction de ce dernier, il y a un appel au destructeur de CEmetteur qui réalise un delete de ma structure Rating.... alors que je ne l'est pas demandé évidemment...

Donc je pense savoir ce qu'il se passe, en amont je crée un objet CEmetteur, et ensuite je le donne en argument dans le constructeur de CExpoEmetteur, et dans ce constructeur j'alloue de la memoire comme ca

_emetteur = new CEmetteur(emetteur);

Dans cette instruction, le constructeur de CEmetteur est appelé, alors que mon objet CEmetteur est déjà créé, donc pour passer de l'un à l'autre il fait appel au destructeur, bien qu'il ne soit pas appelé...
Je sais pas si c'est ca... mais si oui que faut-t-il faire... et sinon... que faire également...

merci beaucoup d'avance
Afficher la suite 

Votre réponse

7 réponses

Meilleure réponse
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Dernière intervention
5 novembre 2018
- 12 juil. 2010 à 17:07
3
Merci
C'est un problème extrêmement classique.

Tu oublies que tout objet est passé par *copie* !!!
Ex:
#include 

class Pouet
{
public:
  Pouet(int* i)
  : _i (i)
  {
    std::cout << "kikoo" << std::endl;
  }
  ~Pouet()
  {
    std::cout << "destroy" << std::endl;
    delete _i;
  }
  int* _i;
};

void testBug(Pouet p)
{
  std::cout << *p._i << std::endl; // Ok la 1ere fois
  // bug, car copie, donc p, et donc i, va se faire detuire ici
  // appel du destructeur, car p est une variable local temporaire
}

void test(const Pouet& p)
{
  std::cout << *p._i << std::endl;
  // ok, car pas de copie !
}

int main()
{
  int* i = new int[1];
  *i = 5;
  Pouet pouet(i);
  test(pouet);
  test(pouet);
  test(pouet);
  testBug(pouet);
  testBug(pouet);
  testBug(pouet);

  return 0;
}


La solution est simple: si tu as des pointeurs en interne deux solutions:
- Tu ne copie jamais ces objets, tu peux désactiver la copie des objets en héritant de boost::noncopyable, ou en laissant la definition des opérateurs de copies, vide.
- Tu réécris les opérateurs de copies, de manière à faire une véritable copie de ce que pointent tes pointeurs.

Ex qui résoud le problème pour l'exemple donné précédemment:
  Pouet(const Pouet& p)
  {
    // On copie pour de vrai, on ne fais pas seulement "pointer le pointeur".
    _i = new int[1];
    *_i = *p._i;
  }


________________________________________________________________________
Historique de mes créations, et quelques articles:[ http://0217021.free.fr/portfolio
http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée quand un post répond à votre question

Merci cptpingu 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 88 internautes ce mois-ci

Commenter la réponse de cptpingu
Messages postés
57
Date d'inscription
mardi 11 mars 2003
Dernière intervention
24 avril 2013
- 12 juil. 2010 à 17:20
0
Merci
Super merci...

j'avais pas pensé à mettre en argument une référence constante...
J'ai opté pour ça du coup... et évidemment ca marche, hehe!!!!

ExpoEmetteur(const CEmetteur& emetteur, autres arguments...) : _autresArguments(autresArgument)
{
_emetteur = new CEmetteur(emetteur);
}


Encore merci!!!
Commenter la réponse de eupeup
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Dernière intervention
5 novembre 2018
- 12 juil. 2010 à 17:27
0
Merci
Quelque soit ta solution, il faut gérer ce cas. Soit en désactivant la copie, soit en la remplaçant.
C'est le genre de bug vicieux qui va vite revenir sinon :p

Soit dit en passant, pense à tout passer en "const&" si tu ne modifies pas l'objet passé en argument. Le différence de performance peut être assez monstrueuse.

________________________________________________________________________
Historique de mes créations, et quelques articles:[ http://0217021.free.fr/portfolio
http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée quand un post répond à votre question
Commenter la réponse de cptpingu
Messages postés
57
Date d'inscription
mardi 11 mars 2003
Dernière intervention
24 avril 2013
- 12 juil. 2010 à 20:06
0
Merci
Ok, merci pour le conseil...

Sinon j'ai fait un tit test et ca marche, en revanche, j'ai un soucis que je comprends pas...

Je reprends mon exemple :
ExpoEmetteur(const CEmetteur& emetteur, autres arguments...) : _autresArguments(autresArgument)
{
_emetteur = new CEmetteur(emetteur);
}

Admettons que je veuille créer un vector d'objet ExpoEmetteur...
Je fais d'abord :

ExpoEmetteur expo = ExpoEmetteur(emetteur, autres arguments...);
vector<ExpoEmetteur> listExpo;
listExpo.push_back(expo);

et ca marche très bien...

En revanche, lorsque je fais

vector<ExpoEmetteur> listExpo;
listExpo.push_back(ExpoEmetteur(emetteur, autres arguments...));

Ca ne marche plus, il repasse par le destructeur... et fait donc un delete de _emetteur...
Est ce normal?? Il me semble que ces deux bouts de code sont semblables...
Ou est ce propre à la classe vector, et il repasse un nouvelle fois en copie et tutti quanti...

Merci d'avance!!!
Commenter la réponse de eupeup
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Dernière intervention
5 novembre 2018
- 13 juil. 2010 à 09:59
0
Merci
ExpoEmetteur expo = ExpoEmetteur(emetteur, autres arguments...);

La syntaxe correcte serait (On evite une copie inutile):
ExpoEmetteur expo(emetteur, autres arguments...);


Si tu ne veux pas appeler le destructeur et le constructeur sans cesse, tu dois faire un std::vector de ExpoEmetteur*.
ExpoEmetteur* expo = new ExpoEmetteur(emetteur, autres arguments...);
std::vector<ExpoEmetteur*> listExpo;
listExpo.push_back(expo);
// Ne pas oublier de détruire tous ce qui est dans le vecteur, une fois que l'on a fini de travailler avec.


PS: Évite absolument le using namespace std, voir: http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace

________________________________________________________________________
Historique de mes créations, et quelques articles:[ http://0217021.free.fr/portfolio
http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée quand un post répond à votre question
Commenter la réponse de cptpingu
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Dernière intervention
5 novembre 2018
- 13 juil. 2010 à 10:04
0
Merci
Ca ne marche plus, il repasse par le destructeur... et fait donc un delete de _emetteur...

Petite précision: cette erreur ne devrait pas arriver. Quelque soit la manière dont tu manies ta classe (donc même avec un std::vector de celle-ci), il ne devrait pas y avoir de problème.
Pour que ta classe soit parfaitement conçu, il est impératif, indispensable, obligatoire et très important que tu redéfinisses l'opérateur de copie ! Ce n'est pas une option ou une méthode alternative.
D'une manière générale, dès que tu as un pointeur dans une classe, l'opérateur doit être recodé.

________________________________________________________________________
Historique de mes créations, et quelques articles:[ http://0217021.free.fr/portfolio
http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée quand un post répond à votre question
Commenter la réponse de cptpingu
Messages postés
57
Date d'inscription
mardi 11 mars 2003
Dernière intervention
24 avril 2013
- 23 juil. 2010 à 18:50
0
Merci
Salut à tous!!!

bon j'ai encore un tit soucis...

D'une part, j'ai une classe définissant un objet CExposition.
D'autre part, j'ai un fichier qui contient une fonction calculExposition() ne prenant rien en argument et retournant un objet CExposition.
Et finalement dans mon main, afin de tester, j'ai codé un truc du genre :

CExposition test = calculExposition();

Et là, j'ai un problème, dans ma fonction tout se passe normalement jusqu'au return, et là patatra, il y a un appel du destructeur de CExposition (sans que je le demande bien sur, hehe)...
J'imagine que c'est à cause de la copie... est ce bien cela? et que faire?

De plus, dans un message précédent, on m'a précisé que pour avoir une classe bien conçue, je dois recoder l'operateur de copie...
Alors je vais poser une question conne, mais l'opérateur de copie est bien l'opérateur '=', c'est bien cela?

Merci d'avance

Peupeu
Commenter la réponse de eupeup

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.