probleme d'effet de bord et respect encapsulation

**Fifou625** · 27/11/2011, 21h19

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** · 27/11/2011, 23h01

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** · 28/11/2011, 00h17

Envoyé par 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.

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** · 28/11/2011, 13h18

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** · 04/12/2011, 22h46

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** · 04/12/2011, 23h08

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

**Fifou625** · 08/12/2011, 22h23

merci pour vos reponses

**oxyde356** · 09/12/2011, 15h00

Des compteurs diagnostiques pour du debug ? Si oui alors OK.
Si non et que c'est utilisé dans ton appli (par exemple dans les scores, etc.) en mon sens ça ne devrait pas être là, en tout cas surement pas en static vu que c'est une donnée.

**Fifou625** · 09/12/2011, 21h22

Envoyé par oxyde356

Des compteurs diagnostiques pour du debug ? Si oui alors OK.
Si non et que c'est utilisé dans ton appli (par exemple dans les scores, etc.) en mon sens ça ne devrait pas être là, en tout cas surement pas en static vu que c'est une donnée.

je vais les virer

probleme d'effet de bord et respect encapsulation

C++

Discussions similaires

Partager

Partager