error C2512: 'Arme'*: aucun constructeur par défaut approprié disponible

Bonjour,

Je suis un debutant en C++. Je voudrais savoir pourquoi mon IDE affiche "error C2512: 'Arme'*: aucun constructeur par défaut approprié disponible". J'ai cherché par tout les moyens pis je n'ai pas trouvé. Quelqu'un peux me montrer la solution svp? merci

Arme.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#ifndef DEF_ARME
#define DEF_ARME
#include <iostream>
#include <string>
 
class Arme
{
private:
	std::string m_nomArme;
	double m_puissanceArme;
	double m_rapiditeArme;
	double m_energieArme;
	double m_resistanceArme;
	int m_levelArme;
 
public:
	Arme(char const& job);
	void information() const;
};
 
#endif

Assassin.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
#ifndef DEF_ASSASSIN
#define DEF_ASSASSIN
#include <iostream>
#include <string>
#include "Monstre.h"
#include "Arme.h"
 
class Monstre;
class Arme;
 
/* Creer les assassins */
class Assassin
{
	/* Les attributs d'un assassin */
private:
	std::string m_nom;
	char m_class;
	double m_hp;
	double m_sp;
	int m_xp;
	int m_level;
	double m_puissance;
	double m_rapidite;
	double m_energie;
	double m_resistance;
	bool m_estVivant;
	Arme m_arme;
 
	/* Les actions que l'assassin peut faire ou recevoir */
public:
	void perdreHp(double nbDegat); 
	void perdreSp(double perte);
	void gagnerXp(int const& levelEnnemi, bool const& ennemiVivant);
	void gagnerHp(bool const& ennemiVivant);
	void gagnerSp(bool const& ennemiVivant);
	void attaquer(Monstre &cible);
	void superAttaque(Monstre &cible);
	bool getVivant() const;
	void information() const;
	Assassin(std::string const& pseudo,char const& job);
	Assassin();
	void gagnerCapacite(bool const& ennemiVivant);
};
 
#endif

Monstre.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
#ifndef DEF_MONSTRE
#define DEF_MONSTRE
#include <iostream>
#include <string>
#include "Assassin.h"
 
class Assassin;
 
/* Creation des Monstres */
class Monstre
{
private:
	/* Attribut des Monstres */
	double m_hp;
	double m_sp;
	int m_level;
	double m_puissance;
	double m_rapidite;
	double m_energie;
	double m_resistance;
	bool m_estVivant;
 
	/* Action que les monstres peuvent recevoir & faire */
public:
	void perdreHp(double const nbDegat);
	void perdreSp(double perte);
	void attaquer(Assassin &cible);
	void superAttaque(Assassin &cible);
	int getLevel() const;
	bool getVivant() const;
	void information() const;
	Monstre(int const& niveauMonstre);
	Monstre();
};
 
#endif

Arme.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
#include "Arme.h"
#include <iostream>
#include <string>
using namespace std;
 
Arme::Arme(char const& job)
{
	m_levelArme = 1;
	switch(job)
	{
	case 'g':
		m_resistanceArme = 10;
		m_nomArme = "Katana en bois";
		break;
	case 'n':
		m_rapiditeArme = 10;
		m_nomArme = "Kunai basic";
		break;
	case 'h':
		m_energieArme = 10;
		m_nomArme = "Baton magique basic";
		break;
	default:
		m_puissanceArme = 10;
		m_nomArme = "knuckle basic";
		break;
	}
}
 
void Arme::information() const
{
	cout << "Nom de l'arme" << m_nomArme << endl;
	cout << "Niveau de l'arme : " << m_levelArme << endl;
	cout << "Puissance : " << m_puissanceArme << endl;
	cout << "Rapidite : " << m_rapiditeArme << endl;
	cout << "Resistance : " << m_resistanceArme << endl;
	cout << "Energie : " << m_energieArme << endl;
}

Assassin.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
233
234
235
236
237
238
239
#include "Assassin.h"
#include "Arme.h"
#include <string>
#include <iostream>
using namespace std;
 
/* Fonction qui fait perdre la vie a l'assassin */
void Assassin::perdreHp(double const nbDegat)
{
	/* Si il est vivant, il pourra perdre de la vie */
	if(m_estVivant = true)
	{
		/* Calculer le nombre de dommage sur l'assassin */
		double perte(nbDegat/m_resistance);
		m_hp -= perte;
		/* Si il succombre, il meurt */
		if(m_hp < 0)
		{
			m_estVivant = false;
			cout << "Vous etes mort" << endl;
		}
		else
		{
			cout << "Vous avez perdu " << perte << " vies" << endl;
		}
	}
	else
	{
		cout << "Vous etes mort" << endl;
	}
}
 
/* Fonction qui fait perdre du Sp a l'assassin */
void Assassin::perdreSp(double perte)
{
	/* Si il y a du Sp, il peut en perdre */
	if(m_sp > 0)
	{
		m_sp -= perte;
	}
	else
	{
		cout << "Pas d'energie" << endl;
	}
}
 
/* La fonction qui permet a l'assassin de gagner des Xp */
void Assassin::gagnerXp(int const& levelEnnemi, bool const& ennemiVivant)
{
	/* Si l'ennemi est mort */
	if(ennemiVivant == false)
	{
		/* Calculer le Xp ramasser */
		int gain = levelEnnemi*40;
		gain /= m_level;
		/* Rajouter le Xp gagner */
		m_xp += gain;
		cout << "Vous avez gagner " << gain << " xp" << endl;
		/* A chaque 100 xp, tu as un level up */
		if(m_xp > 100)
		{
			while(m_xp > 100)
			{
				m_xp -= 100;
				m_level += 1;
				gagnerHp(ennemiVivant);
				gagnerSp(ennemiVivant);
				m_hp += 100;
				m_sp += 100;
				cout << "Felicitation : vous avez atteint le niveau " << m_level << endl;
			}
		}
	}
}
 
/* Fonction qui permet de gagner des Hp */
void Assassin::gagnerHp(bool const& ennemiVivant)
{
	/* Si l'ennemi meurt, tu recois des vies en recompenses */
	if(ennemiVivant == false)
	{
		/* Calculer le nombre de hp que l'assassin merite */
		double gain(m_rapidite/5);
		gain *= 2;
		/* Ajouter le hp merité */
		m_hp += gain;
		cout << "Vous avez gagner " << gain << " vie." << endl;
	}
}
 
/* Fonction qui permet de ganger des Sp*/
void Assassin::gagnerSp(bool const& ennemiVivant)
{
	/* Si l'ennemi meurt, tu recois des sp en recompenses */
	if(ennemiVivant == false)
	{
		/* Calculer le nombre de sp merité */
		double gain(m_rapidite/5);
		gain *= 2;
		/* Ajouter le nombre de sp merité */
		m_sp += gain;
		cout << "Vous avez gagner " << gain << " sp." << endl;
	}
}
 
/* Fonction qui permet de gagner de la capacite*/
void Assassin::gagnerCapacite(bool const& ennemiVivant)
{
	/* Si l'ennemi meurt, tu recois des capacite */
	if(ennemiVivant == false)
	{
		m_puissance += 5;
		m_resistance += 5;
		m_rapidite += 5;
		m_energie += 5;
		cout << "Vous avez gagner 5 puissances" << endl; 
		cout << "Vous avez gagner 5 resistances" << endl;
		cout << "Vous avez gagner 5 rapidites" << endl;
		cout << "Vous avez gagner 5 energies" << endl;
	}
}
 
/* Fonction qui permet a l'assassin d'attaquer un monstre */
void Assassin::attaquer(Monstre &cible)
{
	cout << "Vous avez attaquer" << endl;
	/* Calculer la force d'impacte */
	double forceDattaque(m_puissance*2);
	/* Enlever la vie au monstre */
	cible.perdreHp(forceDattaque);
	/* Si il meurt, l'assassin a gagné */
	if(cible.getVivant() == false)
	{
		gagnerXp(cible.getLevel(),cible.getVivant());
		gagnerHp(cible.getVivant());
		gagnerSp(cible.getVivant());
		gagnerCapacite(cible.getVivant());
	}
}
 
/* Fonction qui permet a l'assassin de faire des attaques magiques */
void Assassin::superAttaque(Monstre &cible)
{
	/* Calculer l'energie qui sera utilisé pendant l'attaque */
	double coutEnergie(999/m_energie);	
	/* Calculer la force d'impacte qui aura */
	double forceDattaque(m_energie*2*m_puissance);
	/* Si l'assassin a assez de sp, il pourra faire la super attaque*/
	if(coutEnergie < m_sp)
	{
		cout << "Vous avez faite un super-pouvoir" << endl;
		/* Perdre l'energie consumé */
		perdreSp(coutEnergie);
		/* La cible recoit l'impacte */
		cible.perdreHp(forceDattaque);
		/* Si le monstre meurt, l'assassin a gagné */
		if(cible.getVivant() == false)
		{
			gagnerXp(cible.getLevel(),cible.getVivant());
			gagnerHp(cible.getVivant());
			gagnerSp(cible.getVivant());
			gagnerCapacite(cible.getVivant());
		}
	}
	else
	{
		cout << "Vous n'avez plus d'energie" << endl;
	}
}
 
/* Fonction qui retourne si l'assassin est en vie ou mort */
bool Assassin::getVivant() const
{
	return m_estVivant;
}
 
/* Fonction qui affiche l'information sur l'assassin */
void Assassin::information() const
{
	cout << endl << "Nom : " << m_nom << endl;
	cout << "Classe : " << m_class << endl;
	cout << "Hp : " << m_hp << endl;
	cout << "Sp : " << m_sp << endl;
	cout << "Xp : " << m_xp << endl;
	cout << "Level : " << m_level << endl;
	cout << "Puissance : " << m_puissance << endl;
	cout << "Rapidite : " << m_rapidite << endl;
	cout << "Resistance : " << m_resistance << endl;
	cout << "Arme : " << "Plastic black dick" << endl << endl;
}
 
/* Creation d'un assassin */
Assassin::Assassin(std::string const& pseudo,char const& job)
{
	m_nom = pseudo;
	m_hp = 100;
	m_sp = 100;
	m_xp = 0;
	m_level = 1;
	m_estVivant = true;
	m_arme = new Arme();
 
	switch(job)
	{
	case 'g':
		m_class = 'g';
		m_puissance = 10;
		m_rapidite = 10;
		m_energie = 10;
		m_resistance = 15;
		break;
	case 'n':
		m_class = 'n';
		m_puissance = 10;
		m_rapidite = 15;
		m_energie = 10;
		m_resistance = 10;
		break;
	case 'h':
		m_class = 'h';
		m_puissance = 10;
		m_rapidite = 10;
		m_energie = 15;
		m_resistance = 10;
		break;
	default:
		m_class = 's';
		m_puissance = 15;
		m_rapidite = 10;
		m_energie = 10;
		m_resistance = 10;
		break;
	}
}
 
/* Assassin par defaut */
Assassin::Assassin() : m_nom("Ken"), m_hp(100), m_sp(100), m_xp(0), m_level(1), m_estVivant(true), m_class('s'), m_puissance(15), m_rapidite(10), m_energie(10), m_resistance(10)
{
}

Monstre.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
#include "Monstre.h"
#include <iostream>
using namespace std;
 
/* Fonction qui fait perdre de la vie du monstre */
void Monstre::perdreHp(double const nbDegat)
{
	/* Si il est vivant, il pourra perdre des vies*/
	if(m_estVivant = true)
	{
		/* calculer le dommage qui aura sur le monstre */
		double perte(nbDegat/m_resistance);
		m_hp -= perte;
		/* Si il succombre, il meurt */
		if(m_hp < 0)
		{
			m_estVivant = false;
			cout << "Le monstre est mort" << endl;
		}
		else
		{
			cout << "Dommage de " << perte << " vies" << endl;
		}
	}
	else
	{
		cout << "Le monstre est mort" << endl;
	}
}
 
/* Fonction de perdre de l'energie */
void Monstre::perdreSp(double perte)
{
	/* Si il y a du sp, le monstre peut en perdre */
	if(m_sp > 0)
	{
		m_sp -= perte;
	}
	else
	{
		cout << "Le monstre n'as d'energie" << endl;
	}
}
 
/* fonction qui permet au monstre de attaquer un assassin */
void Monstre::attaquer(Assassin &cible)
{
	cout << "Le monstre vous a attaquer" << endl;
	/* Calculer la force d'impacte */
	double forceDattaque(5*m_puissance);
	/* Enlever la vie au assassin */
	cible.perdreHp(forceDattaque);
	/* Si la cible meurt. Le monstre a gagné */
	if(cible.getVivant() == false)
	{
		cout << "Le monstre a gagner" << endl;
	}
}
 
/* fonction qui permet au monstre de faire une attaque magique */
void Monstre::superAttaque(Assassin &cible)
{
	/* Calculer l'energie qui sera depensé lors de l'attaque */
	double coutEnergie(19);
	/* Calculer la force d'impacte qui aura */
	double forceDattaque(3*(m_energie*2*m_puissance));
	/* Si le monstre a assez d'energie. Il peut faire la super attaque. */
	if(coutEnergie < m_sp)
	{
		cout << "Le monstre a fait un superpouvoir" << endl;
		/* Perdre l'energie consumé */
		perdreSp(coutEnergie);
		/* La cible recoit l'impacte */
		cible.perdreHp(forceDattaque);
		/* Si l'assassin succombre le monstre gagne */
		if(cible.getVivant() == false)
		{
			cout << "Le monstre a gagner." << endl;
		}
	}
	else
	{
		cout << "Le monstre n'a plus d'energie" << endl;
	}
}
 
/* Fonction qui retourne le level du monstre */
int Monstre::getLevel() const
{
	return m_level;
}
 
/* Fonction qui retourne si le monstre est en vie ou pas */
bool Monstre::getVivant() const
{
	return m_estVivant;
}
 
/* Fonction qui affiche les informations du monstres */
void Monstre::information() const
{
	cout << endl << "Hp : " << m_hp << endl;
	cout << "Sp : " << m_sp << endl;
	cout << "Level : " << m_level << endl;
	cout << "Puissance : " << m_puissance << endl;
	cout << "Rapidite : " << m_rapidite << endl;
	cout << "Resistance : " << m_resistance << endl << endl;
}
 
/* Creation d'un monstre */
Monstre::Monstre(int const& niveauMonstre)
{
	m_level = niveauMonstre;
	m_hp = 15+(5*m_level);
	m_sp = 15+(5*m_level);
	m_puissance = 5*m_level;
	m_rapidite = 5*m_level;
	m_energie = 5*m_level;
	m_resistance = 5*m_level;
	m_estVivant = true;
}
 
/* Monstre par defaut */
Monstre::Monstre() : m_level(1), m_hp(20), m_sp(20), m_puissance(5), m_rapidite(5), m_energie(5), m_resistance(5), m_estVivant(true)
{
}

main.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
#include <iostream>
#include <string>
#include "Assassin.h"
#include "Monstre.h"
#include "Arme.h"
using namespace std;
 
int main()
{
	/* declarer les variables */
	string const pseudo("Mushi");
	char const job('g');
	int const niveauMonstre(1);
 
	/* Creer les objets */
	Assassin niggajutsu(pseudo,job);
	Monstre vampire(niveauMonstre);
 
	/* Bataille */
	niggajutsu.information();
	vampire.information();
 
	niggajutsu.attaquer(vampire);
	vampire.attaquer(niggajutsu);
 
	niggajutsu.information();
	vampire.information();
 
	vampire.superAttaque(niggajutsu);
	niggajutsu.superAttaque(vampire);
 
	niggajutsu.information();
	vampire.information();
 
	Monstre vampire2(2);
 
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
	niggajutsu.attaquer(vampire2);
 
	niggajutsu.information();
	vampire2.information();
 
 
	system("PAUSE");
	return 0;
}