Problème de compilation

Nouvelle compilation, nouvelle erreur! :P Ca devrait être mon slogan.
Bon voila ce coup-ci je comprend pas d'ou peut venir l'erreur retourné.

En fait j'ai deux type d'erreur

Code:

1
2
 
pokemon.cpp:43: error: declaration of `int Pokemon::getStatut()' outside of class is not definition

Bon je comprend pas pourquoi ça me fais ça juste pour une fonction membre alors que toutes les autres marchent.

et j'ai d'autre pars

Code:

pokemon.cpp:149: error: `m_hpMax' undeclared (first use this function)

qui revient pour plein de variable de ma class, alors qu'elles sont définie. Ce que je comprend pas, c'est que lors des précédentes compilations j'avais pas cette erreur. Et j'ai pas modifié mes variables depuis.

voici le pokemon.h

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
#ifndef CLASS_POKEMON
#define CLASS_POKEMON
#include "attaque.h"
#include <iostream>
#include <string>
#include "pokemon.h"
#include "enum.h"
#include "objet.h"
 
class Pokemon
{
   public:
 
   //constructeur et destructeur
   Pokemon();
   ~Pokemon();
 
   //fonction membre get uniquement
   std::string getNomPokemon();
   int getNumeroPokemon();
   int getHpMax();
   int getHp();
   int getLevel();
   int getStatut();
   int getAttaqueStat();
   int getDefesneStat();
   int getAttaqueSpecialStat();
   int getDefenseSpecialStat();
   int getVitesseStat();
   int getType1();
   int getType2();
   std::string getNomAttaque1();
   int getPpAttaque1();
   std::string getNomAttaque2();
   int getPpAttaque2();
   std::string getNomAttaque3();
   int getPpAttaque3();
   std::string getNomAttaque4();
   int getPpAttaque4();
   std::string getSexePokemon();
   int getAnimation();
 
    // action
    void setLevelUp();
    void setRenomerPokemon();
    void setBoosterStatPokemon(int attaqueABooster);
    void setAttaquerPokemon(Pokemon pokemon, Attaque attaque);
    void setRecevoirAttaqueDunPokemon(Pokemon pokemon, Attaque attaque);
    void setUtiliserObejtSurPokemon(Objet objet);
    void setCentrePokemon();
    void setOublierAttaque(int numeroAttaque);
    void setApprendreAttaque(int numeroAttaque,Attaque attaque);
    void setModifierAnimation( int newAnimation);
 
    private:
 
    //definition general
    std::string m_nomPokemon;
    int m_numeroPokemon;
    int m_hpMax;
    int m_hp;
    int m_level;
    int m_sexePokemon;
    int m_statut;
    // statistaque du pokemon
    int m_attaque;
    int m_defense;
    int m_attaqueSpecial;
    int m_defenseSpecial;
    int m_vitesse;
    // modification temporaire des statisiques durant le combat
    int m_attaque_temp;
    int m_defense_temps;
    int m_attaqueSpecial_temp;
    int m_defenseSpecialt_temp;
    int m_vitesse_temp;
    //types du pokemon
    int m_type_1;
    int m_type_2;
    // attaques du pokemon
    Attaque m_attaque_1;
    int m_ppAttaque_1;
    int m_ppMaxAttaque_1;
    Attaque m_attaque_2;
    int m_ppAttaque_2;
    int m_ppMaxAttaque_2;
    Attaque m_attaque_3;
    int m_ppAttaque_3;
    int m_ppMaxAttaque_3;
    Attaque m_attaque_4;
    int m_ppAttaque_4;
    int m_ppMaxAttaque_4;
    //sprite du pokemon
    int m_animation;
 
};
 
 
 
#endif

Et voila le pokemon.cpp

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
#include "pokemon.h"
#include <iostream>
 
//constructeur et destructeur
 
Pokemon::Pokemon()
{
 
}
 
Pokemon::~Pokemon()
{
 
}
 
//fonction membre get uniquement
 
std::string Pokemon::getNomPokemon()
{
    return m_nomPokemon;
}
 
int Pokemon::getNumeroPokemon()
{
    return m_numeroPokemon;
}
 
int Pokemon::getHpMax()
{
    return m_hpMax;
}
 
int Pokemon::getHp()
{
    return m_hp;
}
 
int Pokemon::getLevel()
{
    return m_level;
}
 
int Pokemon::getStatut();
{
    return m_statut;
}
 
int Pokemon::getAttaqueStat()
{
    return m_attaque;
}
 
int Pokemon::getDefesneStat()
{
    return m_defense;
}
 
int Pokemon::getAttaqueSpecialStat()
{
    return m_attaqueSpecial;
}
 
int Pokemon::getDefenseSpecialStat()
{
    return m_defenseSpecial;
}
 
int Pokemon::getVitesseStat()
{
    return m_vitesse;
}
 
int Pokemon::getType1()
{
    return m_type_1;
}
 
int Pokemon::getType2()
{
    return m_type_2;
}
 
std::string Pokemon::getNomAttaque1()
{
    return m_attaque_1.getNomAttaque();
}
 
int Pokemon::getPpAttaque1()
{
    return m_ppAttaque_1;
}
 
std::string Pokemon::getNomAttaque2()
{
    return m_attaque_2.getNomAttaque();
}
 
int Pokemon::getPpAttaque2()
{
    return m_ppAttaque_2;
}
 
std::string Pokemon::getNomAttaque3()
{
    return m_attaque_3.getNomAttaque();
}
 
int Pokemon::getPpAttaque3()
{
    return m_ppAttaque_3;
}
 
std::string Pokemon::getNomAttaque4()
{
    return m_attaque_4.getNomAttaque();
}
 
int Pokemon::getPpAttaque4()
{
    return m_ppAttaque_4;
}
 
std::string Pokemon::getSexePokemon()
{
    if (m_sexePokemon=MALE) {return "MALE";}
    else { return "FEMMELLE";}
}
 
int Pokemon::getAnimation()
{
    return m_animation;
}
 
// action
void setLevelUp()
{
 
}
 
void setRenomerPokemon()
{
 
}
 
void setBoosterStatPokemon(int attaqueABooster,int puissance)
{
    switch(attaqueABooster)
    {
        case 0: m_hpMax+=puissance;
                break;
        case 1: m_attaque+=puissance;
                break;
        case 2: m_defense+=puissance;
                break;
        case 3: m_attaqueSpe+=puissance;
                break;
        case 4: m_defenseSpe+=puissance;
                break;
        case 5: m_vitesse+=puissance;
                break;
        else;
                cout<<"erreur variable attaqueBooster dans class Pokemon eroné" <<endl <<"fonction membre: Pokemon::setBoosterStatPokemon";
    }
}
 
 
void setAttaquerPokemon(Pokemon pokemon, Attaque attaque)
{
 
}
 
void setRecevoirAttaqueDunPokemon(Pokemon pokemon, Attaque attaque)
{
 
}
 
void setUtiliserObejtSurPokemon(Objet objet)
{
 
}
 
void setCentrePokemon()
{
    m_hp=hpMax;
    m_ppAttaque_1=m_ppMaxAttaque_1;
    m_ppAttaque_2=m_ppMaxAttaque_2;
    m_ppAttaque_3=m_ppMaxAttaque_3;
    m_ppAttaque_4=m_ppMaxAttaque_4;
 
}
 
void setOublierAttaque(int numeroAttaque)
{
    Attaque aucuneAttaque;
 
    switch(numeroAttaque)
    {
        case 1: m_attaque_1=aucuneAttaque;
                break;
        case 2: m_attaque_2=aucuneAttaque;
                break;
        case 3: m_attaque_3=aucuneAttaque;
                break;
        case 4: m_attaque_4=aucuneAttaque;
                break;
        else;
        cout<<"erreur variable numeroAttaque dans class Pokemon eronée" <<endl <<"fonction membre: Pokemon::setOublierAttaque";
    }
}
 
void setApprendreAttaque(int numeroAttaque,Attaque attaque)
{
 
    switch(numeroAttaque)
    {
        case 1: m_attaque_1=attaque;
                break;
        case 2: m_attaque_2=attaque;
                break;
        case 3: m_attaque_3=attaque;
                break;
        case 4: m_attaque_4=attaque;
                break;
        else;
        cout<<"erreur variable numeroAttaque dans class Pokemon eronée" <<endl <<"fonction membre: Pokemon::setOublierAttaque";
    }
}
 
void setModifierAnimation( int newAnimation)
{
    m_animation=newAnimation;
}

1/ Tu as un point-virgule qui traîne
Code:

1 2 3 4 int Pokemon::getStatut(); <----- là { return m_statut; }
2/ Tu utilises des variables membres dans une fonction non-membre.

Pour le 1) je savais que c'était un erreur à la con... Comment j'ai pu la loupé 8O
Pour la 2) je comprend pas pourquoi mes fonctions sont pas membre? Enfin je vais jeter un oeil dans mes cours.

Merci beaucoup ;)

Laurent voulait te dire que la fonction n'appartient pas a la class pokemon,
Code:

1 2 void setBoosterStatPokemon(int attaqueABooster,int puissance)
fais comme pour les methode au dessus

Code:

void Pokemon::setBoosterStatPokemon(int attaqueABooster,int puissance)

Ah vi je vois je les ai oublié, mais je dois les mettres aussi dans la déclaration de mes fonctions qui se trouve dans le corps de la class?

Edit c'est bon en faite c'était que des erreurs toute bète. Merci de m'avoir aidé

non juste sur les definitions externes

Oki merci, je note ça dans un petit coin de mon cerveau.;)

De plus, il y a pas mal de fonctions membres que tu peux déclarer const, car elles ne modifient pas l'objet:

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
#include <iostream>
#include <string>
 
class Pokethulhu
{
public:
	Pokethulhu(std::string const &nom);
	~Pokethulhu();
 
	std::string getNom() const;
	int getVitesse() const;
	int getHp() const;
	int getForce() const;
 
	void setNom(std::string const &nom);
	void setVitesse(int vitesse);
	void setHp(int hp);
	void setForce(int force);
 
private:
	int m_vitesse;
	int m_hp;
	int m_force;
	std::string m_nom;
};
 
//Constructeur et destructeur
Pokethulhu::Pokethulhu(const std::string &nom)
 : m_nom(nom)
{ }
 
Pokethulhu::~Pokethulhu()
{ }
 
//Accesseurs
std::string Pokethulhu::getNom() const
{
	return m_nom;
}
 
int Pokethulhu::getVitesse() const
{
	return m_vitesse;
}
 
int Pokethulhu::getHp() const
{
	return m_hp;
}
 
int Pokethulhu::getForce() const
{
	return m_force;
}
 
//Modifieurs
void Pokethulhu::setNom(const std::string &nom)
{
	m_nom = nom;
}
 
void Pokethulhu::setVitesse(int vitesse)
{
	m_vitesse = vitesse;
}
 
void Pokethulhu::setHp(int hp)
{
	m_hp = hp;
}
 
void Pokethulhu::setForce(int force)
{
	m_force = force;
}
 
 
//Tests
void Affich(Pokethulhu const &thulhu)
{
	std::cout << "Nom : " << thulhu.getNom() << std::endl;
}
 
void TestClass(void)
{
	Pokethulhu pikathulhu("Pikathulhu");
	Pokethulhu hastursaur("Hasturzarre");
 
	Affich(pikathulhu);
	Affich(hastursaur);
}

Oui oui,ça je savais, toutes mes fonctions getQuelqueChose peuvent être déclarées en const, mais je vois pas trop l'utilité. 8O

Citation:

Envoyé par mooglwy

Oui oui,ça je savais, toutes mes fonctions getQuelqueChose peuvent être déclarées en const, mais je vois pas trop l'utilité. 8O
Code:

1 2 3 4 5 6 void AfficherHP(const Pokemon& Pok) { std::cout << Pok.getHp() << std::endl; // Erreur de compilation si getHp n'est pas const }