Discussion :

[Fifou625]

Bonjour
le programme suivant marche mais l'encapsulation est brisée .


implementation.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#pragma once
 
#include <iostream>
#include <string>
 
class chargeur_m16
{
	int nb_de_balle;
	static int nb_de_chargeur;
public:
	bool balle_amene_dans_chargeur();
	int nb_de_balle_restante()const;
	const static int cb_de_chargeur();
	bool videQ()const;
	chargeur_m16();
	~chargeur_m16();
};
 
class M_16 
{
	int x,y,z;
	enum type_cadence_de_tir{un_coup,rafale}cadence_de_tir;
	bool balle_amorce;
 
	static int nb_de_coup_tire;
	int f();
public:
	chargeur_m16 *pt;//encapsulation cassée
	bool amorcer_la_balle();
	int tirer();
	void changer_cadence_de_tir();
	void etat_selecteur_cadence_de_tir()const;
	chargeur_m16* emplacement_du_chargeur();
	static void cb_de_coup_tire();
	void changer_chargeur(int numero);
 
	M_16(int a,int b,int c);
	~M_16();
};
 
 
class soldier
{
	int sante;
	int x,y,z;
	std::string nom;
	M_16 *pt;//1 seul arme
	chargeur_m16* sac[10];
	//enum type_grade{PRIVATE,CORPORAL,SERGEANT,LIEUTENANT,CAPTAIN,MAJOR,LIEUTENANT_COLONEL,COLONEL}grade;
public:
 
	soldier(int a,int b ,int c,std::string n);
	~soldier();
 
	void changer_chargeur(int numero);
	M_16& utiliser_arme();
	M_16& soldier::utiliser_arme_pt(soldier &cible,chargeur_m16 *t);//test
	M_16& utiliser_arme(soldier& cible);
	bool vie()const;
	void damage(int a);
	std::string get_nom()const;
};

chargeur_m16.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#include "implementation.h"
 
 int chargeur_m16::nb_de_chargeur=0;
 
chargeur_m16::chargeur_m16():nb_de_balle(30){nb_de_chargeur++;}
chargeur_m16::~chargeur_m16(){nb_de_chargeur--;}
bool chargeur_m16::balle_amene_dans_chargeur(){if(nb_de_balle){nb_de_balle--;return true;}else{return false;}}
int chargeur_m16::nb_de_balle_restante()const{std::cout << "il reste " << nb_de_balle << " balle(s)"<< std::endl;return nb_de_balle; }
const int chargeur_m16::cb_de_chargeur(){return nb_de_chargeur;}
bool chargeur_m16::videQ()const{if(nb_de_balle)return true;else return false;}

M_16.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include <iostream>
#include "implementation.h"
 
 
int M_16::nb_de_coup_tire=0;
 
int M_16::tirer()
{
	int damage=0;
	if(cadence_de_tir==un_coup)
		damage=f();
	else 
		for(int i=0;i<3;i++){damage+=f();}
	return damage;
}
 
bool M_16::amorcer_la_balle()
{
	if(pt->balle_amene_dans_chargeur()){balle_amorce=true;return true;}
 
	else{std::cout << "impossible d'amorce une balle(chargeur vide?) "<< std::endl;return false;}	
}
 
int M_16::f()
{
	if(balle_amorce){std::cout << "pan" << std::endl;balle_amorce=amorcer_la_balle();nb_de_coup_tire++;return 40;}
	else {std::cout << "click (balle non amorce)" << std::endl; return 0;}
}
void M_16::etat_selecteur_cadence_de_tir()const
{
	if(cadence_de_tir==rafale)std::cout << "mode rafale" << std::endl;
	else std::cout << "mode un coup" << std::endl;
}
 
void M_16::changer_cadence_de_tir()
{
	if(cadence_de_tir==rafale)cadence_de_tir=un_coup;
	else cadence_de_tir=rafale;
}
 
M_16::M_16(int a,int b,int c):cadence_de_tir(un_coup),balle_amorce(false),x(a),y(b),z(c){pt=new chargeur_m16;}
M_16::~M_16(){delete pt; }
 
chargeur_m16* M_16::emplacement_du_chargeur(){return pt;}
 
void M_16::cb_de_coup_tire()
{
	std::cout << "l'arme a tire " << nb_de_coup_tire << " coup"<< std::endl;
}

soldier.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include "implementation.h"
 
 
soldier::soldier(int a,int b ,int c,std::string n):sante(100),x(a),y(b),z(c),nom(n)
{
	pt=new M_16(x,y,z);
	for(int i=0;i<10;i++){sac[i]=new chargeur_m16; }
}
 
soldier::~soldier()
{
	for(int i=0;i<10;i++){delete sac[i]; }
	delete pt;
}
 
bool soldier::vie()const
{
	if(sante==0)
	{
		return false;
	}
	else
	{
		return true;
	}
}
 
void soldier::damage(int a)
{
	sante =- a;
	if(sante<0)sante=0;
	if (vie()==false){std::cout <<"vous avez tue "<< get_nom()<< std::endl;}
}
 
std::string soldier::get_nom()const{return nom;}
 
M_16& soldier::utiliser_arme(){if(vie())return *pt;else {std::cout << "vous etes mort" << std::endl; return *pt;}}
 
M_16& soldier::utiliser_arme(soldier &cible)
{
	if(cible.vie())cible.damage(pt->tirer());
	else std::cout << "cible deja bute" << std::endl;
	return *pt;
}
 
M_16& soldier::utiliser_arme_pt(soldier &cible,chargeur_m16 *t)//test
{
	if(cible.vie())cible.damage(pt->tirer());
	else std::cout << "cible deja bute" << std::endl;
	return *pt;
}
 
void soldier::changer_chargeur(int numero)
{
	if(sac[numero])
	{
		chargeur_m16 *temp=pt->pt;// encapsulation cassée
		pt->pt=sac[numero];
		sac[numero]=temp;
	}
	else std::cout << "emplacement vide " << std::endl;
}

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include "implementation.h"
 
int main()
{
 
	soldier ford(4,5,4,"Ford");
	soldier gogol(8,9,6,"gogol");
	ford.utiliser_arme().amorcer_la_balle();
	ford.utiliser_arme().etat_selecteur_cadence_de_tir();
	ford.utiliser_arme().changer_cadence_de_tir();
	ford.utiliser_arme().etat_selecteur_cadence_de_tir();
	ford.utiliser_arme(gogol);
	ford.utiliser_arme(gogol);
	for(int i=0;i<10;i++){ford.utiliser_arme().tirer();}
	ford.utiliser_arme().cb_de_coup_tire();
	ford.utiliser_arme().emplacement_du_chargeur()->nb_de_balle_restante();
	ford.changer_chargeur(0);
	ford.utiliser_arme().amorcer_la_balle();
	for(int i=0;i<10;i++){ford.utiliser_arme().tirer();}
	ford.utiliser_arme().emplacement_du_chargeur()->nb_de_balle_restante();
	ford.changer_chargeur(0);
	ford.utiliser_arme().amorcer_la_balle();
	ford.utiliser_arme().tirer();
	system("pause");
}

j'ai essaye de rendre M_16::chargeur_m16 *pt; privé mais en utilisant des fonction qui renvoi un pointeur en argument de "changer_chargeur()" je n'ai pas d'effet de bord en dehors de la fonction du coup le programme bug avec une fuite de memoire et aussi avec 2 appel du destructeur sur un meme emplacement de memoire ...

avec un friend ca ne compile pas car soldier n'est pas encore definit

est t il possible de definir class soldier avant M_16 pour utiliser friend? le probleme est de trouve un autre moyen d'implementer void soldier::changer_chargeur(int numero); en respectant l'encapsulation soit en la mettant amie je n'y arrive pas ou en utilisant une fonction qui renvoie M_16::*pt;
merci.

[Nekkro]

Dans le .h, tu peux écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#ifndef XX
#define XX
 
class Soldier;
 
class M16 
{
    /* ... */
};
 
#endif // XX

Ainsi tu peux utiliser Soldier comme bon te semble dans le .cpp.

[Fifou625]

Dans le .h, tu peux écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#ifndef XX
#define XX
 
class Soldier;
 
class M16 
{
    /* ... */
};
 
#endif // XX

Ainsi tu peux utiliser Soldier comme bon te semble dans le .cpp.

version remaniée de :

implementation.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#pragma once
 
#include <iostream>
#include <string>
 
class chargeur_m16
{
	int nb_de_balle;
	static int nb_de_chargeur;
public:
	bool balle_amene_dans_chargeur();
	int nb_de_balle_restante()const;
	const static int cb_de_chargeur();
	bool videQ()const;
	chargeur_m16();
	~chargeur_m16();
};
class soldier;
class M_16 
{
	int x,y,z;
	enum type_cadence_de_tir{un_coup,rafale}cadence_de_tir;
	bool balle_amorce;
	chargeur_m16 *pt;//je l'ai mis en privé comme cela devrait l'être
	static int nb_de_coup_tire;
	int f();
public:
 
	bool amorcer_la_balle();
	int tirer();
	void changer_cadence_de_tir();
	void etat_selecteur_cadence_de_tir()const;
	chargeur_m16* emplacement_du_chargeur();
	static void cb_de_coup_tire();
	void changer_chargeur(int numero);
	friend void soldier::changer_chargeur(int numero);//j'ai declarer cette fonction amis
	M_16(int a,int b,int c);
	~M_16();
};
 
 
class soldier
{
	int sante;
	int x,y,z;
	std::string nom;
	M_16 *pt;//1 seul arme
	chargeur_m16* sac[10];
	//enum type_grade{PRIVATE,CORPORAL,SERGEANT,LIEUTENANT,CAPTAIN,MAJOR,LIEUTENANT_COLONEL,COLONEL}grade;
public:
 
	soldier(int a,int b ,int c,std::string n);
	~soldier();
 
	void changer_chargeur(int numero);
	M_16& utiliser_arme();
	M_16& soldier::utiliser_arme_pt(soldier &cible,chargeur_m16 *t);//test
	M_16& utiliser_arme(soldier& cible);
	bool vie()const;
	void damage(int a);
	std::string get_nom()const;
};

le compilateur envoie en sortie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
implementation.h(19)*: voir la déclaration de 'soldier'
\documents\visual studio 2010\projects\soldat\soldat\soldier.cpp(58): error C2248: 'M_16::pt'*: impossible d'accéder à private membre déclaré(e) dans la classe 'M_16'
\documents\visual studio 2010\projects\soldat\soldat\implementation.h(25)*: voir la déclaration de 'M_16::pt'
\documents\visual studio 2010\projects\soldat\soldat\implementation.h(21)*: voir la déclaration de 'M_16'
\documents\visual studio 2010\projects\soldat\soldat\soldier.cpp(59): error C2248: 'M_16::pt'*: impossible d'accéder à private membre déclaré(e) dans la classe 'M_16'
1>          \documents\visual studio 2010\projects\soldat\soldat\implementation.h(25)*: voir la déclaration de 'M_16::pt'
1>          \documents\visual studio 2010\projects\soldat\soldat\implementation.h(21)*: voir la déclaration de 'M_16'
1>  Génération de code en cours...
1>  Compilation en cours...
1>  M_16.cpp
1>\documents\visual studio 2010\projects\soldat\soldat\implementation.h(37): error C2027: utilisation du type non défini 'soldier'
1>          \documents\visual studio 2010\projects\soldat\soldat\implementation.h(19)*: voir la déclaration de 'soldier'
1>  Génération de code en cours...
1>  Compilation en cours...
1>  chargeur_m16.cpp
1>\documents\visual studio 2010\projects\soldat\soldat\implementation.h(37): error C2027: utilisation du type non défini 'soldier'
1>          \documents\visual studio 2010\projects\soldat\soldat\implementation.h(19)*: voir la déclaration de 'soldier'
1>  Génération de code en cours...
1>  Compilation en cours...
1>  main.cpp
1>\documents\visual studio 2010\projects\soldat\soldat\implementation.h(37): error C2027: utilisation du type non défini 'soldier'
1>          \documents\visual studio 2010\projects\soldat\soldat\implementation.h(19)*: voir la déclaration de 'soldier'
1>  Génération de code en cours...
========== Génération*: 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========

[3DArchi]

Salut,

=> La durée de vie du chargeur est probablement de la responsabilité de Soldier et non de M16 qui n'est qu'un utilisateur.
=> M16 aurait alors une couple de fonctions charger/ decharger qui permet de changer de chargeur
=> M16 n'a pas à détruire le chargeur dans son destructeur, c'est de la responsabilité de soldier.
=> toute tes classes, puisqu'elles ont un destructeur non trivial, devrait se poser la question de la copie (voir F.A.Q Qu'est-ce que la forme canonique orthodoxe de Coplien ? et suivante.
=> std::unique_ptr, std::array entre autres
=> je ne comprends pas l'intérêt des variables statiques dans tes classes.

[Fifou625]

le probleme d'encapsulation est reglé c'était simple
pour les variables statiques c'est juste des compteurs diagnostique


implementation.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#pragma once
 
#include <iostream>
#include <string>
#include <vector>
 
 
 
const int MAIN_DEJA_CHARGE=2;
const int MAIN_ETAIT_VIDE=3;
 
 
 
class chargeur_m16 
{
	int nb_de_balle;
	static int nb_de_chargeur;
	chargeur_m16( chargeur_m16 const&);
	chargeur_m16& operator=(chargeur_m16 const&);
public:
	bool balle_amene_dans_chargeur();
	int nb_de_balle_restante()const;
	const static int cb_de_chargeur();
	bool videQ()const;
	chargeur_m16();
	~chargeur_m16();
};
class soldier;
class sol;
class M_16 
{
	int x,y,z;
	enum type_cadence_de_tir{un_coup,rafale}cadence_de_tir;
	bool balle_amorce;
 
	static int nb_de_coup_tire;
	int f();
	chargeur_m16 *pt;
	M_16(M_16 const &);
	M_16& operator=(M_16 const &);
public:
 
	bool amorcer_la_balle();
	int tirer();
	void changer_cadence_de_tir();
	void etat_selecteur_cadence_de_tir()const;
	chargeur_m16* emplacement_du_chargeur();
	static void cb_de_coup_tire();
	void charger(soldier &S);
	void decharger(soldier &);
 
	M_16(int a,int b,int c);
	~M_16();
};
 
 
class sac
{
	std::vector<chargeur_m16*> objet_dans_le_sac;
 
	sac(sac const&);
	sac& operator=(sac const&);
 
public:
	sac();
	~sac();
	chargeur_m16* regarder_dans_le_sac(size_t numero)const;
	void enlever_du_sac(size_t numero,soldier&);
	void mettre_dans_le_sac(size_t numero,soldier&);
};
 
class soldier 
{
	int sante;
	int x,y,z;
	std::string nom;
	M_16 *pt;//1 seul arme
	chargeur_m16* main_gauche;
	sac bag;
 
	soldier(soldier const&);
	soldier& operator=(soldier const&);
 
	//enum type_grade{PRIVATE,CORPORAL,SERGEANT,LIEUTENANT,CAPTAIN,MAJOR,LIEUTENANT_COLONEL,COLONEL}grade;
public:
 
	soldier(int a,int b ,int c,std::string n);
	~soldier();
 
	M_16& utiliser_arme();
	M_16& utiliser_arme(soldier& cible);
	bool vie()const;
	void damage(int a);
	std::string get_nom()const;
	chargeur_m16* utiliser_main_gauche();
	int mettre_dans_la_main_gauche(chargeur_m16*);
	void enlever_de_la_main_gauche();
 
	chargeur_m16* regarder_dans_le_sac(size_t numero)const;
	void enlever_du_sac(size_t numero);
	void mettre_dans_le_sac(size_t numero);
 
};
 
class sol
{
	std::vector<chargeur_m16*> objet_sur_le_sol;
 
	sol(sol const&);
	sol& operator=(sol const&);
public:
	sol();
	void poser_un_objet_au_sol(soldier &);
	void prendre_un_objet_au_sol(int numero,soldier &);
	~sol();
 
};

chargeur_m16.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "implementation.h"
 
 int chargeur_m16::nb_de_chargeur=0;
 
chargeur_m16::chargeur_m16(): nb_de_balle(30){nb_de_chargeur++;}
chargeur_m16::~chargeur_m16(){nb_de_chargeur--;}
bool chargeur_m16::balle_amene_dans_chargeur(){if(nb_de_balle){nb_de_balle--;return true;}else{return false;}}
int chargeur_m16::nb_de_balle_restante()const
{
	if(this)
	{
		std::cout << "il reste " << nb_de_balle << " balle(s)"<< std::endl;return nb_de_balle;
	}
	std::cout << "il n' y a pas de chargeur sur l'arme"<< std::endl;
	return 0;
}
const int chargeur_m16::cb_de_chargeur(){return nb_de_chargeur;}
bool chargeur_m16::videQ()const{if(nb_de_balle)return true;else return false;}

M_16.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include <iostream>
#include "implementation.h"
 
 
int M_16::nb_de_coup_tire=0;
 
int M_16::tirer()
{
	int damage=0;
	if(cadence_de_tir==un_coup)
		damage=f();
	else 
		for(int i=0;i<3;i++){damage+=f();}
	return damage;
}
 
bool M_16::amorcer_la_balle()
{
	if(pt)
	{
		if(pt->balle_amene_dans_chargeur()){balle_amorce=true;return true;}
 
		else{std::cout << "impossible d'amorce une balle(chargeur vide?) "<< std::endl;return false;}
	}
	else{std::cout << "impossible d'amorce une balle(pas de chargeur) "<< std::endl;return false;}
}
 
int M_16::f()
{
	if(balle_amorce){std::cout << "pan" << std::endl;balle_amorce=amorcer_la_balle();nb_de_coup_tire++;return 40;}
	else {std::cout << "click (balle non amorce)" << std::endl; return 0;}
}
void M_16::etat_selecteur_cadence_de_tir()const
{
	if(cadence_de_tir==rafale)std::cout << "mode rafale" << std::endl;
	else std::cout << "mode un coup" << std::endl;
}
 
void M_16::changer_cadence_de_tir()
{
	if(cadence_de_tir==rafale)cadence_de_tir=un_coup;
	else cadence_de_tir=rafale;
}
 
M_16::M_16(int a,int b,int c): cadence_de_tir(un_coup),balle_amorce(false),x(a),y(b),z(c){pt=new chargeur_m16;}
M_16::~M_16(){delete pt; }
 
chargeur_m16* M_16::emplacement_du_chargeur(){return pt;}
 
void M_16::cb_de_coup_tire()
{
	std::cout << "l'arme a tire " << nb_de_coup_tire << " coup"<< std::endl;
}
 
void M_16::charger(soldier &S)
{
	if(!pt) 
	{
		chargeur_m16* main=S.utiliser_main_gauche();
		if(main)
		{
			pt=main;
			S.enlever_de_la_main_gauche();
		}
		else std::cout << "votre main gauche est vide" << std::endl;
	}
	else std::cout << " l'arme a deja un chargeur" << std::endl;
}
 
void M_16::decharger(soldier &S)
{
	if(pt) 
	{
		int error=S.mettre_dans_la_main_gauche(pt);
		if(error==MAIN_ETAIT_VIDE)
			pt=0;
	}
	else std::cout << " l'arme est deja sans chargeur" << std::endl;
}

sac.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include "implementation.h"
 
int error=0;
 
sac::sac()
{
	for(size_t i=0;i<10;i++)
		objet_dans_le_sac.push_back(new chargeur_m16);
}
 
sac::~sac()
{
	if(!(objet_dans_le_sac.empty()))
	{
		for(size_t i=0;i<objet_dans_le_sac.size();i++) {if (objet_dans_le_sac[i])delete objet_dans_le_sac[i];}
		objet_dans_le_sac.clear();
	}
}
 
chargeur_m16* sac::regarder_dans_le_sac(size_t numero)const
{
	if(!(objet_dans_le_sac.empty()))
		if( (numero < objet_dans_le_sac.size())&& objet_dans_le_sac[numero] )
			return objet_dans_le_sac[numero];
		else {std::cout << "il n' y a rien a cet emplacement (dans le sac)" << std::endl;return 0;}
	else {std::cout << "le sac est vide" << std::endl;return 0;}
 
}
 
void sac::enlever_du_sac(size_t numero,soldier& S)
{
	if(!(objet_dans_le_sac.empty()))
		if((numero < objet_dans_le_sac.size()) && objet_dans_le_sac[numero])
		{
			 error=S.mettre_dans_la_main_gauche(objet_dans_le_sac[numero]);
			 if(error==MAIN_ETAIT_VIDE)
				objet_dans_le_sac[numero]=0;
		}
		else std::cout << "il n' y a rien a enlever" << std::endl;
	else std::cout << "le sac est vide" << std::endl;
}
 
void sac::mettre_dans_le_sac(size_t numero,soldier & S)
{
	chargeur_m16* charg=S.utiliser_main_gauche();
	if (charg){
		if((numero < objet_dans_le_sac.size()) && !(objet_dans_le_sac[numero]))
		{
			objet_dans_le_sac[numero]=charg;
			S.enlever_de_la_main_gauche();
		}
		else std::cout << "il n'y a rien dans la main gauche" << std::endl;
	}
}

sol.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include "implementation.h"
 
sol::sol(){}
 
sol::~sol()
{
	for(size_t i=0;i<objet_sur_le_sol.size();i++) {if(objet_sur_le_sol[i]) delete objet_sur_le_sol[i];}
	objet_sur_le_sol.clear();
}
 
 
void sol::poser_un_objet_au_sol(soldier& S)
{
	chargeur_m16* objet=S.utiliser_main_gauche();
	if(objet)
	{
		objet_sur_le_sol.push_back(objet);
		S.enlever_de_la_main_gauche();
	}
	else std::cout << "votre main gauche est vide" << std::endl;
}
 
void sol::prendre_un_objet_au_sol(int numero,soldier& S)
{
	if(objet_sur_le_sol[numero])
	{
		int error=S.mettre_dans_la_main_gauche(objet_sur_le_sol[numero]);
		if(error==MAIN_ETAIT_VIDE)objet_sur_le_sol.at(numero)=0;
	}
	else std::cout << "il n' y a rien sur le sol" << std::endl;
}

soldier.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include "implementation.h"
 
 
soldier::soldier(int a,int b ,int c,std::string n):sante(100),x(a),y(b),z(c),nom(n),main_gauche(0){pt=new M_16(x,y,z);}
 
soldier::~soldier()
{
	delete pt;
	if(main_gauche)delete main_gauche;
}
 
bool soldier::vie()const
{
	if(sante==0) return false;
	else return true;	
}
 
void soldier::damage(int a)
{
	sante =- a;
	if(sante<0)sante=0;
	if (vie()==false){std::cout <<"vous avez tue "<< get_nom()<< std::endl;}
}
 
std::string soldier::get_nom()const{return nom;}
 
M_16& soldier::utiliser_arme(){if(vie())return *pt;else {std::cout << "vous etes mort" << std::endl; return *pt;}}
 
M_16& soldier::utiliser_arme(soldier &cible)
{
	if(cible.vie())cible.damage(pt->tirer());
	else std::cout << "cible deja bute" << std::endl;
	return *pt;
}
 
chargeur_m16* soldier::utiliser_main_gauche(){return main_gauche;}
 
int soldier::mettre_dans_la_main_gauche(chargeur_m16* charg)
{
	if(!main_gauche)
	{
		main_gauche=charg;
		return MAIN_ETAIT_VIDE;
	}
	else std::cout << "votre main est deja charge" << std::endl;
 
	return MAIN_DEJA_CHARGE;
}
 
void soldier::enlever_de_la_main_gauche(){main_gauche=0;}
 
 
chargeur_m16* soldier::regarder_dans_le_sac(size_t numero)const{return bag.regarder_dans_le_sac(numero);}
 
void soldier::enlever_du_sac(size_t numero){bag.enlever_du_sac(numero,*this);}
 
void soldier::mettre_dans_le_sac(size_t numero){bag.mettre_dans_le_sac(numero,*this);}

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#pragma once
#include "implementation.h"
 
int main()
{
	sol terre;
	soldier ford(4,5,4,"Ford");
	soldier gogol(8,9,6,"gogol");
	ford.utiliser_arme().amorcer_la_balle();
	ford.utiliser_arme().etat_selecteur_cadence_de_tir();
	ford.utiliser_arme().changer_cadence_de_tir();
	ford.utiliser_arme().etat_selecteur_cadence_de_tir();
	ford.utiliser_arme(gogol);
	ford.utiliser_arme(gogol);
	for(int i=0;i<10;i++){ford.utiliser_arme().tirer();}
	ford.utiliser_arme().cb_de_coup_tire();
	ford.utiliser_arme().emplacement_du_chargeur()->nb_de_balle_restante();
	ford.utiliser_arme().decharger(ford);
	terre.poser_un_objet_au_sol(ford);
	ford.enlever_du_sac(0);
	ford.utiliser_arme().charger(ford);
	ford.utiliser_arme().amorcer_la_balle();
	for(int i=0;i<10;i++){ford.utiliser_arme().tirer();}
	ford.utiliser_arme().emplacement_du_chargeur()->nb_de_balle_restante();
	ford.utiliser_arme().decharger(ford);
	terre.poser_un_objet_au_sol(ford);
	ford.enlever_du_sac(1);
	ford.utiliser_arme().charger(ford);
	ford.utiliser_arme().amorcer_la_balle();
	ford.utiliser_arme().tirer();
	system("pause");
}

[Fifou625]

il va falloir revoir soldier::utiliser_arme()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
ford.utiliser_arme().amorcer_la_balle();
ford.utiliser_arme().etat_selecteur_cadence_de_tir();
ford.utiliser_arme().changer_cadence_de_tir();
ford.utiliser_arme().etat_selecteur_cadence_de_tir();

etc..
est ce que M_16::amorcer_la_balle();devrait être appeler par soldier::amorcer_la_balle(){pt->amorcer_la_balle();}comme ça plus besoin de ford.utiliser_arme().amorcer_la_balle();
mais plutôt ford.amorcer_la_balle();je suppose que c'est mieux comme code? en OO