Constructeur et polymorphisme

Bonjour à tous,

Je suis en train de réaliser un p'tit jeu de rôle pour me faire la main (et une PTI au passage, les BTS IG comprendront), et je bloque sur un point :
 voici le code :

Guerrier.h

#ifndef GUERRIER_H_INCLUDED
#define GUERRIER_H_INCLUDED

#include <iostream>
#include <string>
#include "Personnage.h" 

classGuerrier:publicPersonnage
{
private:
public:
Guerrier(std::stringHerosnom);
virtual~Guerrier();
virtualvoidFaitplusmal(Personnage&cible);
};

#endif // GUERRIER_H_INCLUDED


Magicien.h 

#ifndef MAGICIEN_H_INCLUDED
#define MAGICIEN_H_INCLUDED

#include <iostream>
#include <string>
#include "Personnage.h"

classMagicien:publicPersonnage
{
public:
Magicien(std::stringHerosnom);
~Magicien();
voidbouleDeFeu(Personnage&cible);
voidbouleDeGlace(Personnage&cible);
voidsortdeSoin();

protected:
intmana;
};

#endif // MAGICIEN_H_INCLUDED

Personnage.h

#ifndef PERSONNAGE_H_INCLUDED
#define PERSONNAGE_H_INCLUDED

#include <iostream>
#include "Arme.h"

classPersonnage
{
protected:
std::stringm_nom;
intm_vie;
intm_mana;
std::stringm_nomarme;
intm_degatsarme;
std::stringm_metier;

public:
Personnage();
Personnage(std::stringHerosnom);
Personnage(std::stringnomArme,intdegatsArme);
Personnage(constPersonnage&personnageACopier);// Le prototype du constructeur de copie
virtual~Personnage(void);
virtualvoidrecevoirDegats(intnbDegats);
virtualvoidattaquer(Personnage&cible);
virtualvoidboirePotionDeVie(intquantitePotion);
virtualvoidchangerArme(std::stringnomNouvelleArme,intdegatsNouvelleArme);
virtualvoidafficherPV();
virtualboolestVivant();
virtualintretounerPV();
virtualintretourneDegatsArme();
virtualstd::stringRetournerMetier();
virtualvoidFaitplusmal(Personnage&cible);
virtualvoidbouleDeFeu(Personnage&cible);
virtualvoidbouleDeGlace(Personnage&cible);
virtualvoidsortdeSoin();
};


#endif // PERSONNAGE_H_INCLUDED

Selon le déboggeur, ça coince dans Magicien.cpp :

#include <string>
#include "Magicien.h"

usingnamespacestd;


Magicien::Magicien(stringHerosnom)
{
m_nom=Herosnom;
m_vie=100;
m_mana=100;
m_nomarme="Baton";
m_degatsarme=5;
m_metier="Magicien";
}

Magicien::~Magicien()
{
}

voidMagicien::bouleDeFeu(Personnage&cible)
{
if(m_mana==0)
{
cout<<"Vous n'avez plus de Mana"<<endl;
}
else
{
cible.recevoirDegats(10);
m_mana-=5;
}

}

voidMagicien::bouleDeGlace(Personnage&cible)
{
if(m_mana==0)
{
cout<<"Vous n'avez plus de Mana"<<endl;
}
else
{
cible.recevoirDegats(10);
m_mana-=5;
}
}

voidMagicien::sortdeSoin()
{
cout<<"Vous regagnez vingt points de vie"<<endl;
m_vie+=20;
m_mana-=10;
}




Mon problème ? Le code ne se compile pas correctement, la même erreur apparait à des dizaines de reprises : undefined
reference to 'Personnage::~Personnage()', qui a très probablement un
rapport avec les virtuals... Y a t-il un moyen de contourner cela ?

En vous remerciant !

Oui, je l'avais fait par la suite, et je viens de le retenter, mais ceci ne change rien au problème...

Peux-tu, dans ce cas, essayer de poster un morceau indépendant de ton code, qui ne fonctionne pas, en essayant de simplifier au maximum le code qui pose problème ? En précisant bien entendu les erreurs que tu obtiens.

Le problème, c'est que je ne sais pas du tout ce qui ne fonctionne pas... Que ce soit Visual Studio, ou bien Code::Blocks, tous deux m'annoncent le même problème :

undefined reference to 'Personnage::~Personnage()'

à plusieurs reprise sans savoir précisément d'où vient le problème (sauf en ce qui
concerne Code::Blocks, qui précise que le problème vient du constructeur de magicien...).

Sans code, je vais avoir du mal à t'aider...
Quelques pistes:
- Créer des destructeurs dans chaques classes, en "virtual"
- Vérifier qu'un destructeur indiqué dans un header (.h ou .hh), soit bien implémenté dans le fichier de code associé (.cpp ou .cc).
- Vérifier que les inclusions soient correctes.

J'ai trouvé le problème ^^. Merci pour m'avoir indiqué la voie à suivre !  En fait, j'avais mis par mégarde le destructeur de personnage en commentaire.

C'est vraiment triste de perdre presque une journée pour une erreur aussi bête... Merci encore !