méthode sur un pointeur appelant une méthode sur un pointeur

Bonjour a tous,

Je continue le programme donné en exemple d'un tutoriel et j'ai un problème de pointeur. Après pas mal d'essai voici ce que je pense être le problème :

Dans le main si j'écrit la ligne suivante et que j'éxécute le programme, celui-ci compile sans m'indiquer d'erreur mais lorsque vient le moment d'effectuer cette ligne en particulier le programme plante ("RPG.exe a cessé de fonctionner") :

Code:

cout << perso->portee();

Avec dans la classe Personnage de mon code la fonction :

Code:

int Personnage::portee() const {return m_arme->getPortee();}

Le Personnage possède un pointeur déclaré de cette façon :

Code:

Arme* m_arme;

et dans la classe Arme :

Code:

int Arme::getPortee() const {return m_portee;}

Je me demande donc si un appel de méthode sur un pointeur appelant elle-même une méthode sur un pointeur est possible ou conflictuel...

Je suis tout ouï :) et merci d'avance de vos réponses!

Bonjour,

l'un de tes pointeurs semble ne pas être initialisé.

En fait dans le main je déclare un tableau de pointeur pointant vers les différents personnages du jeu. je le déclare de cette manière :

Code:

std::vector<Personnage*> perso;

et dans le code donné plus haut je n'ai pas indiqué perso[i] afin d'éviter de surcharger la page. De plus ce système fonctionne bien pour le reste et je ne pense pas qu'il soit la cause du problème.

Mais le problème reste le même si j’écris

Code:

cout << perso[i]->portee();

Salut,

Pourrais tu donc, au minimum, nous donner le code complet de

ta fonction main()
ta définition de Personage
ton implémentation du constructeur de Personnage
C'est tout pour commencer

(j'ai une idée bien précise du problème, mais je voudrais avoir la certitude et ma boule de crystal est en réparation :aie:)

Sans cela, nous seront limités à des supputations, et ce n'est vraiment pas gai pour nous :D

Bonjour,

Citation:

Envoyé par bl4cksky

Je me demande donc si un appel de méthode sur un pointeur appelant elle-même une méthode sur un pointeur est possible ou conflictuel...

Oui c'est possible, et non en aucun cas conflictuel et fort heureusement.
Du moment que tous les pointeurs pointent bien, bien entendu.

bonjour,

@koala01
D'abord merci de t'intéresser à mon problème.

Voici mon main (note que pas mal de trucs vienne d'un autre problème auquel tu avais déjà répondu :P )

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
#include <iostream>
#include <stdexcept>
#include <vector>
#include <cmath>
 
#include "Personnage.h"
#include "time.h"
#include "Case.h"
#include "Plateau.h"
#include "Coordonnee.h"
#include "Arme.h"
 
using namespace std;
 
Personnage* & get_personnage_by_name(std::vector<Personnage*> & tableaupersos)
{
    bool fini(false);
    string cible("rien");
    while (fini==false)
    {
        cout << "Nommez la cible : ";
        cin >> cible;
        for (std::size_t i = 0; i < tableaupersos.size(); ++i)
        {
            if (tableaupersos[i]->getName() == cible)
                { return tableaupersos[i];
                fini=true;}
        }
        cout << "Cette cible n'est pas valable. ";
    }
}
 
bool VerifActif (std::vector<Personnage*> & persos)    //verifie qu'au moins un perso est actif
{
    int compteur(0);
    for (int i=0;i<persos.size();i++)
    {
        compteur+= (int) persos[i]->estActif();
    }
    if (compteur>=1)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
bool VerifVivant (std::vector<Personnage*> & persos)   //le combat continue tant qu'au moins 1 perso est vivant
{
    int compteur(0);
    for (int i=0;i<persos.size();i++)
    {
        compteur+= (int) persos[i]->estVivant();
    }
    if (compteur>1)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
 
struct Mover { // struct et class sont strictement pareil en C++, à
               // l'exception de la visibilité par défaut ;)
 
    Mover(Plateau & pl):pl_(pl){}
    Plateau & pl_;
 
    void operator()(Personnage * perso)
    {
        int x;
        int y;
        bool place(false);
 
        do
        {
        cout << "Entrez les coordonnees : x=";
        cin >> x;
        cout << "y=";
        cin >> y;
 
        if (pl_.estLibre(Coordonnee(x,y)))
            {
            // on récupère la coordonnée actuelle du personnage
            Coordonnee const & old = perso->coordonnee();
            // on indique au plateau que le personnage quitte cette coordonnée
            pl_.persoQuitte(old);
            //on indique au plateau que le personnage arrive sur la nouvelle coordonnee
            pl_.persoArrive(perso,Coordonnee(x,y));
            // on indique la nouvelle coordonnee au personnage
            perso->deplacer(Coordonnee(x,y));
            place=true;
            perso->devientInactif();
            }
        else
            {
                cout << "Cette case est deja occupee!" << endl;
            }
        }while (place==false);
    }
};
 
struct Attack
{
    Attack(Plateau & pl, std::vector<Personnage*> persos):pl_(pl), persos_(persos){}
    Plateau & pl_;
    std::vector<Personnage*> persos_;
 
    void operator ()(Personnage * perso)
    {
        std::vector<Personnage*> aPortee;
        for (int i=0;i<persos_.size();i++)
        {
            int dx=( persos_[i]->x() - perso->x());
            int dy=( persos_[i]->y() - perso->y());
            if (sqrt ( (dx*dx) + (dy*dy) ) <= perso->portee() && perso->getEquipe()!=persos_[i]->getEquipe() )
            {
                aPortee.push_back(persos_[i]);
            }
        }
 
        if (aPortee.size()!=0)
        {
        cout << "les cibles a portee sont :" << endl;
        for (int i=0;i<aPortee.size();i++)
        {
            cout << aPortee[i]->getName() << endl;
        }
 
        Personnage* & victime = get_personnage_by_name(persos_);
        perso->attaquer(victime);
        perso->devientInactif();
        }
        else {cout << "Aucune cible n'est a portee!!" << endl;}
    }
 
};
 
 
int main() //----------------------------------------------- MAIN ----------------------------------------------------------------------------
{
    string action("rien");
    string nom ("rien");
    int team;
    int posX;
    int posY;
    bool creation(true);
 
    time temps;                             //initialisation d'un compteur de temps pour l'initiative
    Plateau plateau(10,10);                 //initialisation du plateau de jeu
    std::vector<Personnage*> persos;        //creation d'un tableau dynamique de classe Personnage
    Mover m(plateau);
    Attack a(plateau, persos);
 
    do{
            cout << "Creation des personnages : tapez [new] pour creer un nouveau personnage, ou [fin] pour passez a l'etape suivante." << endl;
            cin >> action;
    if (action=="new")
        {
            cout << "Nommez votre personnage : ";
            cin >> nom;
            cout << "Placez-le : x=";
            cin >> posX;
            cout << " et y=";
            cin >> posY;
            cout <<"Dans quelle equipe est-il/elle? (Donnez un numero) : ";
            cin >> team;
            Personnage * perso = new Personnage(nom, Coordonnee(posX,posY),team);
            plateau.persoArrive(perso,Coordonnee(posX, posY));
            persos.push_back(perso);
        }
        else if (action=="fin")
        {
            creation=false;
        }
        else if (action=="test")
        {
            Personnage * david = new Personnage("David", Coordonnee(1,1),1);
                plateau.persoArrive(david,Coordonnee(1, 1));
                persos.push_back(david);
            Personnage * goliath = new Personnage("Goliath",Coordonnee(8,8),2);
                plateau.persoArrive(goliath,Coordonnee(8, 8));
                persos.push_back(goliath);
                goliath->gagneArme(Arme(), 1);
                goliath->gagneArme(Arme("fronde", 5, 4), 1);
            creation=false;
        }
    }while (creation);
 
   for (int i=0;i<persos.size();i++)
        {                                   //affichage de l'état des persos
            persos[i]->afficherEtat();
            cout << endl;
        }
    cout << endl;
 
while (VerifVivant(persos))         //si au moins un perso est vivant
    {
    while (VerifActif(persos))      //si au moins un perso est actif
        {
            temps.compteurIncrem();     //incrémentation du compteur temps
                for ( int i=0 ; i<persos.size() ; i++)
                {
                 if (temps.getCompteur()==persos[i]->getIni())       //si l'initiative d'un perso vaut le compteur
                    do                       //alors le perso joue
                    {
                    cout << "Tour de " << persos[i]->getName() << endl;
                    action=persos[i]->tour();
 
                    if (action=="objets")     {}//persos[i]->utiliserObjet();}
 
                    else if (action=="attaquer")    {a(persos[i]);}
                    else if (action=="deplacer")    {m(persos[i]);}
                    else if (action=="armes")       {persos[i]->changerArme();}
                    else if (action=="rien")        {persos[i]->nefaisrien();}
 
                    }while (persos[i]->estActif()==1);
                }
        }
    temps.compteurReinit();                                             //lorsque tous les persos ont joué, le compteur est remis à zéro
    for (int i=0;i<persos.size();i++)
        {
            persos[i]->devientActif();                                   //tous les persos sont réactivés
        }
    for (int i=0;i<persos.size();i++)
        {
            persos[i]->afficherEtat();                                   //on affiche leurs états
            cout << endl;
        }
    for(int i=0;i<10;++i)
        {
            for(int j = 0; j<10;++j)
                {
                cout << plateau.persoSurCase(Coordonnee(j,i));
                }
                cout << endl;
        }
    }
 
    return 0;
}

Mon Personnage.ccp :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
//Personnage.h
#ifndef PERSONNAGE_H_INCLUDED
#define PERSONNAGE_H_INCLUDED
 
#include "arme.h"
#include "Coordonnee.h"
#include "InvArme.h"
#include <vector>
 
//déclaration de la classe et de ses méthodes et attributs
class Personnage
{
    public:
 
    Personnage(std::string m_nomPersonnage, Coordonnee const & c, int equipe);      //constructeur
 
    Personnage(std::string m_nomPersonnage, std::string nomArme, int degatsArme,
               int porteeArme, int m_vie, int m_mana,int ini, Coordonnee const & c, int equipe, int gold);
 
    ~Personnage();      //destructeur
 
    //actions
    std::string tour();
    void attaquer(Personnage* &cible);
    void deplacer(Coordonnee const & c);
    void nefaisrien();
    void changerArme();
    void utiliserConsommable();
    std::vector<PE> comptePE();
 
    //changements d'etat
    void recevoirDegats(int nbDegats);
    void gagnerVie(int quantite);
    void devientActif();
    void devientInactif();
    void gagneArme(Arme armeAj, int quantite);
 
    //accesseurs
    bool estVivant() const;
    bool estActif() const;
    void afficherEtat() const;
    std::string getName() const;
    Coordonnee const & coordonnee();
    int getVie() const;
    int getVieMax() const;
    int getIni() const;
    int getGold() const;
    int getEquipe() const;
    int x() const;
    int y() const;
    int portee() const ;
 
    private:
 
    std::vector<std::string> m_menuTour;
 
    std::string m_nomPersonnage;
    int m_vie;
    unsigned int m_mana;
    unsigned int m_viemax;
    unsigned int m_ini;
    unsigned int m_gold;
    int m_equipe;
    bool m_estActif;
    Coordonnee m_coord;
    InvArme m_invarme;
 
    //equipement utilisé
    Arme* m_arme;                       //pointeurs : & donne la valeur dans l'adresse et * donne l'adresse du pointeur
 
    //caracteristiques
    unsigned int m_for;
    unsigned int m_dex;
    unsigned int m_con;
    unsigned int m_pui;
    unsigned int m_pot;
    unsigned int m_lvl;
};
 
#endif // PERSONNAGE_H_INCLUDED
 
 
//Personnage.ccp
#include <string>
#include "Personnage.h"
 
using namespace std;
 
Personnage::Personnage(string nomPersonnage, Coordonnee const & c, int equipe) : m_nomPersonnage(nomPersonnage), m_vie(100), m_mana(100),
    m_viemax(m_vie),m_estActif(true),m_coord(c), m_equipe(equipe), m_arme(0),
    m_lvl(1), m_for(10), m_dex(10), m_con(10), m_pui(10), m_pot(10), m_ini(20),m_gold(100)
{
    m_menuTour.push_back("deplacer");
    m_menuTour.push_back("attaquer");
    m_menuTour.push_back("armes");
    m_menuTour.push_back("objets");
    m_menuTour.push_back("rien");
}
 
Personnage::Personnage(string nomPersonnage, string nomArme, int degatsArme, int porteeArme,
                       int vie, int mana, int ini, Coordonnee const & c, int equipe,int gold) :
    m_nomPersonnage(nomPersonnage), m_vie(vie), m_mana(mana), m_viemax(m_vie),m_estActif(true), m_coord(c), m_equipe(equipe), m_arme(0),
    m_lvl(1), m_for(10), m_dex(10), m_con(10), m_pui(10), m_pot(10), m_ini(ini),m_gold(gold)
{
    m_invarme.ajouteItem(Arme(nomArme, degatsArme, porteeArme), 1);
    m_menuTour.push_back("deplacer");
    m_menuTour.push_back("attaquer");
    m_menuTour.push_back("armes");
    m_menuTour.push_back("objets");
    m_menuTour.push_back("rien");
}
 
Personnage::~Personnage()           //destructeur
{
 
}
 
//-------------------------------- ACTIONS -----------------------------------------------------
 
string Personnage::tour()
{
    for (int i=0;i<m_menuTour.size();i++)
    {
        cout << i+1 << " = " << m_menuTour[i] << "     ";
    }
    cout << endl;
        int choix;
 
        cout << "Indiquez le numero de l'action a effectuer :";
        cin >> choix;
        return m_menuTour[choix-1];
}
 
void Personnage::attaquer(Personnage* &cible)
{
    cout << m_nomPersonnage << " attaque " << cible->getName() << "." << endl;
    cible->recevoirDegats(10);
    cout << endl;
    m_estActif=false;
}
 
void Personnage::changerArme()
{
    vector<Arme> const& tableau(m_invarme.renvoi());
  //  tableau=m_invarme.renvoi();
    for (int i=0;i<tableau.size();i++)
    {
        cout << i+1 << " = " << tableau[i].getName() << "     ";
    }
    int choix;
    string util;
 
    cout << "Indiquez le numero de l'objet a utiliser :";
    cin >> choix;
    m_arme = m_invarme.renvoiCase(choix-1);
    cout << m_nomPersonnage << " change d'arme et prends " << m_arme->getName() << "." << endl;
    m_estActif=false;
}
 
void Personnage::nefaisrien()
{
    m_estActif=false;
    cout << m_nomPersonnage << " ne fais rien." << endl;
}
 
void Personnage::deplacer(Coordonnee const & c)     {m_coord=c;}
 
/*
void Personnage::utiliserConsommable()
{
    vector<Objet> tableau;
    tableau=m_inventaire.itemParType("Consommable");
    for (int i=0;i<tableau.size();i++)
    {
        cout << i+1 << " = " << tableau[i].getName() << "     ";
    }
    int choix;
    string util;
 
    cout << "Indiquez le numero de l'objet a utiliser :";
    cin >> choix;
 
}
*/
 
vector<PE> Personnage::comptePE()
{
    vector<PE> PEtot;
    vector<PE> PEarme(m_arme->comptePE());
    for (int i=0;i<PEarme.size();i++)
    {
        PEtot.push_back(PEarme[i]);
    }
    return PEtot;
}
 
//------------------------------ CHANGEMENTS D'ETAT --------------------------------------------
void Personnage::recevoirDegats(int nbDegats)
{
    m_vie -= nbDegats;
    //On enlève le nombre de dégâts reçus à la vie du personnage
 
    if (m_vie < 0) //Pour éviter d'avoir une vie négative
    {
        m_vie = 0; //On met la vie à 0 (cela veut dire mort)
        cout << m_nomPersonnage << " recoit " << nbDegats << " points de degats et meurt." << endl;
    }
    else
    {
    cout << m_nomPersonnage << " recoit " << nbDegats << " points de degats." << endl;
    }
}
 
void Personnage::gagnerVie(int quantite)
{
    m_vie += quantite;
    if (m_vie > m_viemax)  {m_vie = m_viemax;}
}
 
void Personnage::gagneArme(Arme armeAj, int quantite)  {m_invarme.ajouteItem(armeAj, quantite);}
 
void Personnage::devientActif() {m_estActif=true;}
 
void Personnage::devientInactif() {m_estActif=false;}
 
//--------------------------- ACCESSEURS --------------------------------
 
bool Personnage::estVivant() const
{
    if (m_vie > 0)    {return true;}
    else              {return false;}
    cout << endl;
}
 
void Personnage::afficherEtat() const
{
    cout << m_nomPersonnage << ", equipe : " << m_equipe << endl;
    cout << "Vie : " << m_vie << "/" << m_viemax << endl;
    cout << "Coordonnees : x=" << m_coord.x() << " y=" << m_coord.y() << endl;
    if (m_arme==0)       {cout << m_nomPersonnage << " n'a pas d'arme";}
    else                {m_arme->afficher();}
}
 
bool Personnage::estActif() const
{
      if (m_estActif == true)    {return true;}
            else                 {return false;}
}
 
string Personnage::getName() const {return m_nomPersonnage;}
 
const Coordonnee& Personnage::coordonnee() {return m_coord;}
 
int Personnage::getVie() const {return m_vie;}
 
int Personnage::getVieMax() const {return m_viemax;}
 
int Personnage::getIni() const {return m_ini;}
 
int Personnage::getGold() const {return m_gold;}
 
int Personnage::getEquipe() const {return m_equipe;}
 
int Personnage::x() const {return m_coord.x();}
 
int Personnage::y() const{return m_coord.y();}
 
int Personnage::portee() const {return m_arme->getPortee();}

et mon Arme.ccp :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
//Arme.h
#ifndef ARME_H_INCLUDED
#define ARME_H_INCLUDED
 
#include <iostream>
#include <string>
#include <vector>
 
#include "Objet.h"
#include "PEemp.h"
 
class Arme : public Objet
{
    public:
 
    Arme();
    Arme(std::string nom, int degats, int portee);
    void afficher() const;
    void ajoutePE(PE pe);
    std::vector<PE> comptePE() const;
    int getDegats() const;
    int getPortee() const;
 
 
    private:
 
    int m_degats;
    int m_portee;
    int m_PEcap;
    std::vector<PEemp> m_PEemp;
};
 
#endif // ARME_H_INCLUDED
 
 
//Arme.ccp
#include "Arme.h"
 
using namespace std;
 
Arme::Arme() : Objet(1, "Epee rouillee", "Arme"), m_degats(10), m_portee(1)
{
 
}
 
Arme::Arme(string nom, int degats, int portee) : Objet(1, nom, "Arme"), m_degats(degats), m_portee(portee)
{
 
}
 
void Arme::afficher() const
{cout << "Arme : " << m_nom << " (Degats : " << m_degats << ")" << " (portee : " << m_portee << ")" << endl;}
 
//accesseur
int Arme::getDegats() const     //sert à récupérer un attribut et à le renvoyer puisque les autres fichiers ne peuvent pas accéder aux attributs (car privés!!!)
{
    return m_degats;  // const car elle ne change pas l'objet
}
 
void Arme::ajoutePE(PE pe)
{
    int i;
    cin >> i;
    m_PEemp[i].ajoutePE(pe);
}
 
vector<PE> Arme::comptePE()  const
{
    vector<PE> tableau;
    for (int i=0;i<m_PEemp.size();i++)
    {
        for (int j=0;j<m_PEemp[i].getsize();j++)
        {
            tableau.push_back(m_PEemp[i].getPE(j));
        }
    }
    return tableau;
}
 
int Arme::getPortee() const {return m_portee;}

Il y a d'autres classes mais je ne pense pas qu'elles aient un intérêt ici. C'est pour cette raison que je n'ai mis que les bouts de code paraissant problématique, pensant que ca serait moins long et chiant a lire :)

@Bousk

Merci de cette réponse pour le moins ... ambigue....

Je demande si c'est possible OU conflictuel et tu me réponds "non".... j'en pense quoi? ;)

Cela dit j'ai quand même compris que c'était possible :)

Citation:

Envoyé par bl4cksky

bonjour,

@koala01
D'abord merci de t'intéresser à mon problème.

De rien ;)

Citation:

Voici mon main (note que pas mal de trucs vienne d'un autre problème auquel tu avais déjà répondu :P )

C'est très possible, mais comme je répond à énormément de questions... j'espère que tu ne m'en voudra pas de ne pas forcément m'en souvenir :D ;)

Je me souviens d'avoir déjà abordé le problème des personnages de RPG dans différentes discussions, quant à savoir lesquelles exactement, c'est un peu plus ardu (et j'ai pas le courage de vérifier ce soir ;)).

Ceci dit, oui, le code que tu nous a donné suffit en effet, car il confirme l'une des hypothèses que j'envisageais.

si tu regarde bien les constructeurs de ta classe Personnage, tu remarqueras que tu initialises le membre m_arme à 0 (ou, si tu préfères, à NULL), ce qui correspond, comme chacun le sait, à une adresse connue pour être invalide.

(Notes au passage qu'il serait grandement préférable d'utiliser explicitement NULL, voir nullptr si tu disposes de C++11, c'est plus clair que d'utiliser 0 ;)).

Ce pointeur ne pointera (si tout va bien, car j'ai trop chaud pour analyser le code en détail ce soir) vers une adresse valide qu'une fois que tu auras appelé la fonction changerArme avec un paramètre correct.

Tant que cette fonction n'a pas été invoquée, tu ne peux en aucun cas essayer d'accéder à m_arme->getPortee, vu que ton personnage est sensé... ne pas avoir d'arme.

C'est, en gros, toute l'utilité mais aussi tout le problème des pointeurs: il existe un cas particulier qui permet de représenter "l'inexistence" (ou dans le cas présent, l'absence) de l'objet que le pointeur est susceptible de représenter.

tu l'auras compris: le fait que l'adresse représentée par le pointeur soit NULL (nullptr en C++11) représente justement l'absence ou l'inexistence de l'objet.

Cela implique que tu te trouves, en définitive, face à l'obligation de vérifier systématiquement la présence (l'existence) de l'objet avant d'essayer d'y accéder (sauf quand il s'agit d'appeler delete dessus, car c'est garanti sans effet quand invoqué sur une adresse nulle), autrement, tu occasionneras ce que l'on appelle un "comportement indéfini" (undefined behaviour) qui, dans le cas présent, est "mis en avant" par une erreur de segmentation.

Evidemment, tu t'attends à obtenir une portée, même si ton personnage n'est pas armé! Il faut donc que tu définisse une valeur "cohérente" de portée lorsqu'il n'est pas armé. Elle pourrait être, par exemple, d'à peu près un mètre, même si c'est une valeur tout à fait arbitraire.

Au final la fonction Personnage::getPortee() devrait donc ressembler à quelque chose comme
Code:

1 2 3 4 5 6 int Personnage::portee() const { if(m_arme==NULL) // si le personnage n'est pas armé return 1; //sa portée est celle de l'allonge du bras pour donner un coup de poing // autrement return m_arme->getPortee(); //c'est la portée de son arme }

Merci beaucoup c'était ça. Je pensais que si le pointeur pointait vers 0 la méthode "portee" donnerait 0 mais c'est une adresse, donc il ne renvoi rien...

Et que tu ne t'en souvienne pas n'est pas un pb, mais si je le commercialise t'aura ton pseudo dans les credits !! :D