Bonjour, j'apprends actuellement le C++ avec un livre et j'ai pas compris comment associer des classes entre-elles. Quelqu'un m'a donc expliqué mais je ne comprend pas pourquoi je suis obligé d'appeler 2 constructeurs !
Le mien, et celui par défaut.

Personnage::Personnage(int vie, int taille)
{
    Sante = vie;
    Taille = taille;
    weapon.ChoisirDegats(100);
}

Personnage::Personnage()
{
}

Ce serait pas de l'héritage par hasard ? Dans ce cas le constructeur de la classe fille appelle le constructeur de la classe mère.
PS: Ne pas être méchant si je suis à côté de la plaque.

Je sais pas j'en suis pas encore à l'héritage :s

Quels constructeurs sont appellés ? peut-on voir la définition de ta classe Personnage ?

Personnage.hpp :

class Personnage
{
    private:
    char Initiale;
    int Sante;
    int Taille;
    Arme weapon;

    public:
    Personnage(int vie, int taille);
    Personnage();
    ~Personnage();

    char AfficherInitiale();
    void ChoisirInitiale(char Lettre);

    int AfficherSante();
    void ChoisirSante(int Vie);

    int AfficherTaille();
    void ChoisirTaille(int LaTaille);

};

Si je comprend bien, ce qui te gêne c'est de définir 2 constructeurs. D'après ton code, il y a deux manières de déclarer un objet de classe Personnage:

Personnage perso1; //constructeur par défaut
Personnage perso2(100, 195); //l'autre constructeur 
//le personnage a 100pv et mesure 195cm

Les deux constructeurs sont surchargés et seulement l'un des deux sont appellés.
Je te conseille de donner des valeurs par défaut lorsque tu appelles le constructeur par défaut:

Personnage::Personnage()
{
    Initiale = Initial_par_defaut;
    Sante = Sante_par_defaut;
    // etc ...
}

Euh, j'ai pas compris là...

Il faut voir les constructeurs comme une usine qui crée des "Personnages". Cette usine àplusieurs possibilités pour faire un "Personnage", soit elle le fait par défaut, c'est-à-dire que la personne qui fait la commande à l'usine ne peut pas choisir les options (comme pour une voiture si tu prends le modèle qui est dans le catalogue). On construit alos un objet comme ceci:

Personnage David; //Aucune option

Mais l'usine peut aussi créer des "Personnages" avec des options (voiture avec toit ouvrant, clim,...) et il y a donc une autre fillière de construction mais pour l'utiliser, celui qui commande la construction d'un "Personnage" doit alors obligatoirement fournir les options qu'il veut. La création de l'objet se fait alors comme :

Personnage Goliath(100,195);

Je sais pas si mon analogie est claire.

Je comprend assez mais sa répond pas trop à ma question, enfin je croit !

Voici tout le code :

Personnage.hpp :

#ifndef PERSONNAGE_HPP
#define PERSONNAGE_HPP
#include "Arme.hpp"

class Personnage
{
    private:
    char Initiale;
    int Sante;
    int Taille;
    Arme weapon;

    public:
    Personnage(int vie, int taille);
    Personnage();
    ~Personnage();

    char AfficherInitiale();
    void ChoisirInitiale(char Lettre);

    int AfficherSante();
    void ChoisirSante(int Vie);

    int AfficherTaille();
    void ChoisirTaille(int LaTaille);

};

#endif

Personnage.cpp :

#include "Personnage.hpp"

Personnage::Personnage(int vie, int taille)
{
    Sante = vie;
    Taille = taille;
    weapon.ChoisirDegats(100);
}

Personnage::Personnage()  //Ici le problème ! 
{                                         //Quand j'enlève ce constructeur, sa compile plus alors que j'en ai un au dessus
}

Personnage::~Personnage()
{
}

char Personnage::AfficherInitiale()
{
    return Initiale;
}
void Personnage::ChoisirInitiale(char Lettre)
{
    Initiale = Lettre;
}

int Personnage::AfficherSante()
{
    return Sante;
}
void Personnage::ChoisirSante(int Vie)
{
    Sante = Vie;
}

int Personnage::AfficherTaille()
{
    return Taille;
}
void Personnage::ChoisirTaille(int LaTaille)
{
    Taille = LaTaille;
}

Arme.hpp :

#ifndef ARME_HPP
#define ARME_HPP

class Arme
{
    private:
    int Degats;

    public:
    Arme(int w_Degats);
    Arme();
    ~Arme();

    int AfficherDegats();
    void ChoisirDegats(int LeDegat);
};

#endif

Et enfin, Arme.cpp :

#include "Arme.hpp"

Arme::Arme(int w_Degats)
{
    Degats = w_Degats;
}

Arme::Arme()
{
}

Arme::~Arme()
{
}

int Arme::AfficherDegats()
{
    return Degats;
}

void Arme::ChoisirDegats(int LeDegat)
{
    Degats = LeDegat;
}

Oui, mais moi je comprends pas ton problème.

c'est simple (je crois..), je comprends pas pourquoi je suis obligé de mettre un 2ieme constructeur dans Personnage.cpp

Tu n'es pas obligé. Tu eux très bien faire une usine qui ne permet pas aux personnes qui commandent de choisir les options de leurs voitures.

Il faut que tu mettes les constructeurs qui ont un sens pour toi. Si tu veux pas que l'utilisateur ait le choix, alors suelement un constructeur par défaut, si tu veux laisser des options, alors ajoute d'autres constructeurs.

Oui, mais pourquoi quand j'enlève celui par défaut sa plante ?

Je suppose que dans ton main() tu as essayé de l'utiliser. Alors qu'il n'existe pas.

Mon main est vide.

Dans des cas comme ici (manipulation d'entités et pas de valeurs), j'ai tendance à ne mettre aucun constructeur par défaut.

Par contre, cela nécessite d'utiliser les listes d'initialisation pour construire l'arme depuis le constructeur du personnage.

Sa compile pas tout simplement parce que dans ton .hpp tu déclares deux constructeurs... donc faut bien que tu en définisses deux dans ton .cpp...