C++

problème avec le constructeur de copie

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : problème avec le constructeur de copie

razuki

Bonjour,

J'ai défini un classe Personnage. J'essaie de copier le Personnage goliath vers le Personnage david comme suit :

Code :

int main()
{
Personnage goliath("Epée aiguisée", 20);
Personnage david = goliath;
...
}

Voici les constructeurs que j'ai crée dans la classe Personnage :

Code :

Personnage::Personnage() : m_vie(100), m_mana(100)
{
m_arme = new Arme();
}
Personnage::Personnage(string nomArme, int degatsArme) : m_vie(100), m_mana(100)
{
m_arme = new Arme(nomArme, degatsArme);
}

Le compilateur me dit alors :

Undefined reference to 'Personnage::Personage(Personnage const& )

Ma question :
-- Le compilateur ne crée - t - il pas automatiquement le constructeur de copie ?
-- le problème serait - il ailleurs ?

Merci d'avance pour votre aide.

Message édité par razuki le 01-02-2011 à 17:51:52

Publicité

mr simon

Dans le code que tu as poste, il y a deux fois le meme constructeur. J'imagine que tu as un constructeur par defaut et un constructeur prenant deux parametres.

Le compilateur devrait creer un constructeur de recopie par defaut ... Mais dans ton cas, il ne sera pas bon car, les pointeurs m_arme "pointront" vers la meme "arme" (le constructeur par defaut se contentant de copier coller les valeurs des membres de l'objet copie). Il faut donc que tu definisses un constructeur de recopie faisant une copie correct des pointeurs (donc au moins de m_arme).

razuki

Le problème est résolu. En fait j'ai déclaré le constructeur de copie mais je ne l'ai pas défini ...
Sinon un autre problème toujours lié au constructeur de copie ( et donc tu as parlé un peu dans ta réponse ) :

-- j'ai deux Personnage david et goliath qui ont un pointeur arme pointant vers le meme objet arme (voir main ci-dessus).
-- j'ai détruit david ( d'abord son arme, puis lui meme ), puis j'ai détruit goliath et ceux en fin de main( )

Code :

goliath.~Personnage();
david.~Personnage();

Ma question :
est-ce normal que le compilateur ne rale pas, que le programme ne plante pas ... ?
En effet quand je détruit goliath l'arme disparait avec lui. Quand je tente de détruire david, le compilateur est censé cherche son arme ... NON ?

Merci d'avance pour votre aide.

Message cité 1 fois

shaoyin

razuki a écrit :

Code :

goliath.~Personnage();
david.~Personnage();

:heink:

Comment supprimes-tu des objets, toi ? "delete", ca te parle ?

Poste un peu le code de ton destructeur, pour voir.

razuki

Code :

Personnage::~Personnage()
{
delete m_arme;
}

Message édité par razuki le 01-02-2011 à 17:50:39

shaoyin

Pour l'instant, je ne vois pas d'où vient ce prodige, mais j'ai deux remarques à faire :

1) On n'appelle JAMAIS un destructeur directement. Il faut toujours passer par "delete". Je parierai que si tu remplace tes deux horribles appels aux destructeurs par des "delete" en bonne et due forme, ton programme va se planter comme tu t'y attends.

2) L'opérateur "delete" fait deux choses : il invoque le destructeur de l'objet ET il libère la mémoire occupée par cet objet.

Si dans ta fonction ~Personnage() tu avais appelé m_arme->~Arme() au lieu de faire un "delete m_arme", l'espace mémoire occupé par m_arme n'aurait pas été libéré, donc ca aurrait pu expliquer pourquoi ca ne posait pas de souci de "détruire" cette ressource commune.

Message édité par shaoyin le 01-02-2011 à 18:26:48

xilebo

noone

Dans ton constructeur par copie, ce n'est pas l'adresse de "arme" que tu dois dupliquer, mais l'objet "arme". Chaque objet Personnage doit avoir sa propre "arme".

Message cité 1 fois

razuki

J'ai vu quelque part que le compilateur fait appel implicitement au destructeur. C'est ce que shaoyin voulait me dire ppeut etre dans son 1). J'ai aussi essayé de ne pas mettre les deux lignes ci-dessous au début, mais le compilateur ne rale pas non plus. Je m'attendais à ce qu'il rale.
1. goliath.~Personnage();
2. david.~Personnage();

razuki

Si j'ai bien compris :
1) le compilateur (?) détruit implicitement systématiquement david et goliath avant de terminer le programme.
2) Je n'ai donc pas besoin de faire appel au destructeur.

david utilise une arme A, goliath utilise la meme arme A. Les deux pointent sur le meme objet A.
-- le compilateur (?) détruit implicitement systematiquement david ET donc son arme => OK
-- le compilateur (?) détruit implicitement systematiquement goliath MAIS il ne trouve pas l'arme de celui-ci car l'arme a été détruite avec david ...

Pourquoi le compilateur ne rale pas ?

Message cité 1 fois

mr simon

razuki a écrit :

Si j'ai bien compris :
1) le compilateur (?) détruit implicitement systématiquement david et goliath avant de terminer le programme.
2) Je n'ai donc pas besoin de faire appel au destructeur.

1) Oui chaque variable est detruite lorsqu'elle sort du scope:

Code :

int main() {
  Personnage a;
  {
      Personnage b;
  } // destruction de "b"
} // destruction de "a"

2) on n'appelle jamais un destructeur manuellement. Par contre, tu DOIS utiliser "delete" pour liberer memoire allouee par "new", celui-ci se chargera d'appeler le destructeur (ou les destructeurs en cas d'heritage)

Ensuite le compilateur en tant que tel ne te dira jamais rien sur ce genre de probleme (ca serait trop facile ), c'est a l'execution que ca plantera (memoire corrompue). Ce code devrait planter:

Code :

int main(void)
{
    Personnage a("epee", 20);
    Personnage b = a;
    return 0;
}

Message édité par mr simon le 02-02-2011 à 01:13:27

Publicité

hephaestos

Sanctis Recorda, Sanctis deus.

xilebo a écrit :

Dans ton constructeur par copie, ce n'est pas l'adresse de "arme" que tu dois dupliquer, mais l'objet "arme". Chaque objet Personnage doit avoir sa propre "arme".

Pas forcément, s'il y a beaucoup de personnages et une banque de données d'arme, et que chaque personnage ne modifie pas sa propre arme il aurait meilleur compte à implémenter une classe de banque d'armes qui instancie les armes utilisées sur demande, et à fournir à chaque personnage une fonction donnant accès à une référence vers une arme constante :

Code :

const Arme& getArme();

hephaestos

Sanctis Recorda, Sanctis deus.

Dans tous les cas, les pointeurs bruts c'est la porte ouverte à toutes les fenêtres, c'est pas la la solution ici.

Message cité 1 fois

esox_ch

hephaestos a écrit :

Dans tous les cas, les pointeurs bruts c'est la porte ouverte à toutes les fenêtres, c'est pas la la solution ici.

:lol:

---------------
Si la vérité est découverte par quelqu'un d'autre,elle perd toujours un peu d'attrait

razuki

Bonjour,
Je débute en C++ et j'aimerais provoquer des erreurs justement à l'exécution pour voir comment ca fonctionne.

Voici mon code Personnage.h :

Code :

class Personnage
{
public:
Personnage();
Personnage(std::string nomArme, int degatsArme);
Personnage(const Personnage &personnageACopier);
void recevoirDegats(int nbDegats);
void attaquer(Personnage &cible);
void boirePotionDeVie(int quantitePotion);
void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
bool estVivant();
void afficherEtat();
~Personnage();
private:
int m_vie;
int m_mana;
Arme* m_arme;
//std::string m_nomArme; // Pas de using namespace std, donc il faut mettre std:: devant string.
//int m_degatsArme;
};

Voici mon code Personnage.cpp :

Code :

#include <iostream>
#include <string>
#include "Personnage.h"
using namespace std;
//Personnage::Personnage() : m_vie(100), m_mana(100), m_nomArme("Epée rouillée" ), m_degatsArme(10) {}
Personnage::Personnage() : m_vie(100), m_mana(100)
{
m_arme = new Arme();
}
//Personnage::Personnage(string nomArme, int degatsArme) : m_vie(100), m_mana(100), m_arme(nomArme, degatsArme) {}
Personnage::Personnage(string nomArme, int degatsArme) : m_vie(100), m_mana(100)
{
m_arme = new Arme(nomArme, degatsArme);
}
Personnage::Personnage(const Personnage &personnageACopier)
{
m_vie = personnageACopier.m_vie;
m_mana = personnageACopier.m_mana;
m_arme = personnageACopier.m_arme;
//m_arme = new Arme(*(personnageACopier.m_arme));
}
Personnage::~Personnage()
{
delete m_arme;
}
void Personnage::recevoirDegats(int nbDegats)
{
m_vie -= nbDegats;
if (m_vie < 0)
m_vie = 0;
}
void Personnage::attaquer(Personnage &cible)
{
cible.recevoirDegats(m_arme->getDegats());
}
void Personnage::boirePotionDeVie(int quantitePotion)
{
m_vie += quantitePotion;
if (m_vie > 100)
m_vie = 100;
}
void Personnage::changerArme(std::string nomNouvelleArme, int degatsNouvelleArme)
{
m_arme->changer(nomNouvelleArme, degatsNouvelleArme);
}
bool Personnage::estVivant()
{
if (m_vie > 0)
return true;
else
return false;
}
void Personnage::afficherEtat()
{
cout << "Vie : " << m_vie << endl;
cout << "Mana : " << m_mana << endl;
m_arme->afficher();
}

Mon main :

Code :

int main()
{
// Création des personnages
//Personnage david, goliath("Epée aiguisée", 20);
Personnage goliath("Epée aiguisée", 20);
Personnage david = goliath;
// Au combat !
goliath.attaquer(david);
david.boirePotionDeVie(20);
goliath.attaquer(david);
david.attaquer(goliath);
goliath.changerArme("Double hache tranchante vénéneuse de la mort", 40);
goliath.attaquer(david);
// Temps mort ! Voyons voir la vie de chacun...
cout << "David" << endl;
david.afficherEtat();
cout << endl << "Goliath" << endl;
goliath.afficherEtat();
//goliath.~Personnage();
//david.~Personnage();
return 0;
}

le résultat après execution :

Code :

David
Vie : 40
Mana : 100
Arme : Epée aiguisée (Dégâts : 20)
Goliath
Vie : 80
Mana : 100
Arme : Double hache tranchante vénéneuse de la mort (Dégâts : 40)

Donc là le programme ne plante pas, contrairement à quoi je m'attendais.

Message édité par razuki le 02-02-2011 à 12:16:42

shaoyin

Hum... d'un côté, ton programme est en train de se terminer lorsque se passe la double destruction du champ "m_arme". Alors le plantage n'est peut-être pas vraiment mis en évidence.

Tu peux essayer de mettre tout le contenu de ta fonction "main" (sauf le 'return 0;') dans un bloc, et de faire d'autres choses après ce bloc (des écritures sur std::cout, par exemple).

hephaestos

Sanctis Recorda, Sanctis deus.

C'est bizarre que tu te retrouves avec deux armes différentes alors qu'effectivement ton constructeur de copie garde le même pointeur...

shaoyin

J'avais pas fait gaffe à ca...

Message édité par shaoyin le 02-02-2011 à 14:09:31

hephaestos

Sanctis Recorda, Sanctis deus.

Oui, et il devrait aussi changer l'arme de David quand il change l'arme de Goliath, et ce n'est pas le cas.

Message édité par hephaestos le 02-02-2011 à 14:09:05

shaoyin

razuki, tu peux poster le code de ta classe "Arme", stp ?

razuki

shaoyin > j'ai regroupé toutes les instructions dans main( ) ( sauf return 0 ) dans un bloc. Puis j'ai rajouté un cout << "test" à l'extérieur du bloc. Effectivement il n'affiche pas "test" quand David et Goliath possèdent le meme objet arme. Par contre, "test" s'affiche bien quand les deux personnages possède deux objets armes différents.

Hephaestos> moi non plus j'ai pas remarqué qu'il n'a pas changé l'arme de David ...

Je vais voir plutard et je vous tiendrai au courant.

mr simon

Je serais bien curieux de voir le code de la classe Arme, car avec le code que tu as poste, je ne vois pas comment David peut garder son arme (je ne peux meme pas imaginer comment realiser cela avec le code du constructeur de recopie que tu as).

Es tu sur que tu as poster le bon code pour Personnage, car si tu as :

Code :

m_arme = new Arme(*(personnageACopier.m_arme));

(qui est en commentaire), ca marchera.

PS1: Pour les arguments de type std::string, utiliser une reference constante (i.e const std::string& ) est presque toujours une bonne idee!
PS2: Rendre les methodes constantes (par exemple afficherEtat()) est aussi une bonne pratique

razuki

Code :

class Arme
{
public:
Arme();
Arme(std::string nom, int degats);
void changer(std::string nom, int degats);
void afficher();
int getDegats() const;
//string setNomArme() const;
private:
std::string m_nom;
int m_degats;
};
#endif

.cpp

Code :

Arme::Arme() : m_nom("Epée rouillée" ), m_degats(10)
{
}
Arme::Arme(string nom, int degats) : m_nom(nom), m_degats(degats)
{
}
void Arme::changer(string nom, int degats)
{
m_nom = nom;
m_degats = degats;
}
void Arme::afficher()
{
cout << "Arme : " << m_nom << " (Dégâts : " << m_degats << " )" << endl;
}
int Arme::getDegats() const
{
return m_degats;
}

mr simon

Rien de bien extraordinaire la dedans.

Es-tu sur de ta sortie? car ca n'a pas de sens pour moi ...

shaoyin

Moi aussi, je sèche complètement sur ce problème...

Publicité

FORUM HardWare.fr

Programmation

C++

problème avec le constructeur de copie

Sujets relatifs
Problème de compilation avec Code Block	probleme de comparaison
[VBA Excel] Problème ComboBox et Function [Résolu]	Problème scrollbar page perso
probleme d'exécution	Problème de connexion malgré les bons identifiants
Probleme verification champ formulaire javascript	A supprimer
Problème d'affiche en PHP	[MAC]Probleme html et swf
Plus de sujets relatifs à : problème avec le constructeur de copie

Page générée en 0.109 secondes