Discussion :

[Fifou625]

bonjour

le probleme dans le programme suivant est de pouvoir pointer sur des objets heterogènes à chaque emplacement d'équipement . ex : main_gauche=M_16 , sac=chargeur_m16

j'ai plusieurs idées : (exclusive entre elles)

-> utilisation de cast avec un tableau d'enumeration pour identifier chaque objet

-> utilisation de class de base objet_ramassable ( abstaite? , interface commune : mettre() , poser() , consulter()?)(tout les objets derive de cette classe si ils sont ramassable) avec typeid . ou dynamic_cast ?

-> utilisation d'une abstraction: les emplacement ne pointe plus sur les objet en question(construit avec un pointeur sur objet_id) , plutot les objet sont dans des conteneur homogene .
les anciens pointeur pointe sur des conteneur d'objet_id qui ont un identifiant unique plus un identifiant de type (plus besoin de cast)

-> utilisation d'objet objet_ramassable qui a pour membre un pointeur sur un objet (ex m_16) (avec cast?) ou alors utilisation programmation generique?


==>quelle choix de conception est conseillé dans un simulacre de jeu pour les objets heterogenes
code actuel (objets homogenes)

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
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
 
#pragma once
#include <iostream>
#include <string>
#include <vector>
 
 
const int MAIN_DEJA_CHARGE=2;
const int MAIN_ETAIT_VIDE=3;
const int DEPLACEMENT_SOLDAT_IMPOSSIBLE=4;
const int DEPLACEMENT_SOLDAT_OK=5;
 
 
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 
{
 
	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();
	~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 tout_le_sol;
 
class soldier 
{
	int sante;
	int x,y;
	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 ,std::string n);
	~soldier();
 
	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);
 
	void amorcer_la_balle();
	void tirer();
	void tirer(soldier&);
	void changer_cadence_de_tir();
	void etat_selecteur_cadence_de_tir()const;
	void cb_de_coup_tire();
	void charger();
	void decharger();
 
	void nb_de_balle_restante_du_chargeur_de_l_arme()const;
	void nb_de_balle_restante_du_chargeur_de_la_main_gauche()const;
 
	void poser_un_objet_au_sol(tout_le_sol&);
	void prendre_un_objet_au_sol(int numero,tout_le_sol&);
 
	int get_position_x()const;
	int get_position_y()const;
 
 
 
 
};
 
class sol
{
	std::vector<chargeur_m16*> objet_sur_le_sol;
	soldier* presence_soldat;
 
	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 &);
 
	void enlever_soldat();
	int placer_soldat(soldier&);
	soldier& pt_du_soldat()const;
	~sol();
 
};
 
class tout_le_sol
{
	sol parcelle_de_sol[40][40];
	tout_le_sol(tout_le_sol const&);
	tout_le_sol& operator=(tout_le_sol const&);
public:
	tout_le_sol();
	~tout_le_sol();
 
	void poser_un_objet_au_sol(soldier &,int x , int y);
	void prendre_un_objet_au_sol(int numero,soldier &,int x , int y);
 
	void enlever_soldat(int x , int y);
	int placer_soldat(soldier&,int x , int y);
	soldier& pt_du_soldat(int x , int y)const;
};
 
class jeu
{
  std::vector<soldier*> vec_slt;
  tout_le_sol T;
 
  jeu(jeu const&);
  jeu& operator=(jeu const&);
 
  void create_soldat(int x , int y ,std::string nom,tout_le_sol&,std::vector<soldier*>&);
  void destroy_soldat(tout_le_sol&,std::vector<soldier*>&);
public:
  jeu();
  ~jeu();
 
  void create_soldier_public(int x , int y ,std::string nom);
  soldier* selection_unite(int x,int y);
 
  tout_le_sol& quel_terrain();
 
};

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
19
#pragma once
#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;}

jeu.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
#pragma once
#include "implementation.h"
 
 
jeu::jeu(){}
 
jeu::~jeu(){destroy_soldat(T,vec_slt);}
 
 
 
void jeu::create_soldat(int x , int y ,std::string nom,tout_le_sol& T,std::vector<soldier*>&vec_slt )
{
	if(vec_slt.empty())
	{
		T.placer_soldat(*(new soldier(x,y,nom)),x,y);
		vec_slt.push_back(&(T.pt_du_soldat(x,y)));
	}
	else 
	{
		for(size_t i=0;i<vec_slt.size();i++)
		{
			if ((x==(vec_slt[i]->get_position_x()))&& (y==(vec_slt[i]->get_position_y())))
			{
				std::cout << "soldat deja present a cet emplacement ou obstacle" << std::endl;
				break;
			}
			else 
			{
				T.placer_soldat(*(new soldier(x,y,nom)),x,y);
				vec_slt.push_back(&(T.pt_du_soldat(x,y)));
				break;
			}
 
		}
 
	}
}
 
void jeu::destroy_soldat(tout_le_sol& T,std::vector<soldier*>&)
{
	for(size_t i=0;i<vec_slt.size();i++)
	{
		if(vec_slt[i])
		{
			int pos_x,pos_y=0;
			pos_x=vec_slt[i]->get_position_x();
			pos_y=vec_slt[i]->get_position_y();
			T.enlever_soldat(pos_x,pos_y);
			delete vec_slt[i];
		}
	}
	vec_slt.clear();
 
}
 
void jeu::create_soldier_public(int x , int y ,std::string nom){create_soldat(x,y,nom,T,vec_slt);}
 
soldier* jeu::selection_unite(int x,int y)
{
	if(&(T.pt_du_soldat(x,y))) 
		return &(T.pt_du_soldat(x,y));
	else 
		std::cout << "vous n avez pas selectionné de soldat" << std::endl;
	return 0;
}
 
tout_le_sol& jeu::quel_terrain(){return T;}

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#pragma once
#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(this)
	{
		if(cadence_de_tir==rafale)std::cout << "mode rafale" << std::endl;
		else std::cout << "mode un coup" << std::endl;
	}
	else std::cout << "vous n'avez pas d'arme" << std::endl;
}
 
void M_16::changer_cadence_de_tir()
{
	if(this)
	{
		if(cadence_de_tir==rafale)cadence_de_tir=un_coup;
		else cadence_de_tir=rafale;
	}
	else std::cout << "vous n'avez pas d'arme" << std::endl;
}
 
M_16::M_16(): cadence_de_tir(un_coup),balle_amorce(false){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(this)
	{
		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;
	}
	else std::cout << "vous n'avez pas d'arme" << std::endl;
}
 
void M_16::decharger(soldier &S)
{
	if(this)
	{
		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;
	}
	else std::cout << "vous n'avez pas d'arme" << std::endl;
}

tout_le_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
#pragma once
#include "implementation.h"
 
tout_le_sol::tout_le_sol(){}
 
tout_le_sol::~tout_le_sol(){}
 
void tout_le_sol::poser_un_objet_au_sol(soldier &S,int x , int y){(parcelle_de_sol[x][y]).poser_un_objet_au_sol(S);}
 
void tout_le_sol::prendre_un_objet_au_sol(int numero,soldier &S,int x , int y){(parcelle_de_sol[x][y]).prendre_un_objet_au_sol(numero,S);}
 
void tout_le_sol::enlever_soldat(int x , int y){(parcelle_de_sol[x][y]).enlever_soldat();}
 
int tout_le_sol::placer_soldat(soldier&S,int x , int y){return(parcelle_de_sol[x][y]).placer_soldat(S);}
 
soldier& tout_le_sol::pt_du_soldat(int x , int y)const{return(parcelle_de_sol[x][y]).pt_du_soldat();}

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
55
#pragma once
#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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#pragma once
#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;
	}
}

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#pragma once
#include "implementation.h"
 
//TODO verifier this dans chaque fonction (existence du soldat)
soldier::soldier(int a,int b ,std::string n):sante(100),x(a),y(b),nom(n),main_gauche(0){pt=new M_16();}
 
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;}
 
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);}
 
void soldier::amorcer_la_balle(){pt->amorcer_la_balle();}
 
void soldier::tirer(){pt->tirer();}
 
void soldier::tirer(soldier& cible)
{
	if(cible.vie())cible.damage(pt->tirer());
	else std::cout << "cible deja bute" << std::endl;
}
 
void soldier::changer_cadence_de_tir(){pt->changer_cadence_de_tir();}
 
void soldier::etat_selecteur_cadence_de_tir()const{pt->etat_selecteur_cadence_de_tir();}
 
void soldier::cb_de_coup_tire(){M_16::cb_de_coup_tire();}
 
void soldier::charger(){pt->charger(*this);}
 
void soldier::decharger(){pt->decharger(*this);}
 
void soldier::nb_de_balle_restante_du_chargeur_de_l_arme()const{pt->emplacement_du_chargeur()->nb_de_balle_restante();}
 
void soldier::nb_de_balle_restante_du_chargeur_de_la_main_gauche()const{main_gauche->nb_de_balle_restante();}
 
void soldier::poser_un_objet_au_sol(tout_le_sol& T){T.poser_un_objet_au_sol(*this,x,y);}
 
void soldier::prendre_un_objet_au_sol(int numero,tout_le_sol& T){T.prendre_un_objet_au_sol(numero,*this,x,y);}
 
int soldier::get_position_x()const{return x;}
 
int soldier::get_position_y()const{return y;}

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
#pragma once
#include "implementation.h"
 
void action(soldier* S,soldier* E,jeu& J)
{
	if(S && E) 
	{
		S->amorcer_la_balle();
		S->tirer(*E);
		S->decharger();
		S->poser_un_objet_au_sol(J.quel_terrain());
		S->enlever_du_sac(0);
		S->charger();
		S->tirer();
		S->changer_cadence_de_tir();
		S->tirer();
	}
}
 
int main()
{
	jeu U;
	U.create_soldier_public(0,4,"thomas");
	U.create_soldier_public(0,5,"garfield");
 
	action(U.selection_unite(0,4),U.selection_unite(0,5),U);
 
	system("pause");
	return 0;
}

[Kaamui]

je ne suis pas sur d'avoir bien compris, mais tu souhaite pouvoir accéder
à des objets de classe différente dans un même espace, genre tableau ?

Le mieux (pour moi) en terme de conception, c'est bien sur l'utilisation de l'héritage.

TU créé une classe d'objet_ramassable, abstraite, de laquelle héritent chacun des élément que tu peux loger dans ta main ou dans ton sac.

Tu créé ensuite un tableau contenant des objet_ramassable, ce qui te permettra d'avoir ton M16 et son chargeur cote à cote sans que cela ne pose problème.

hétérogène ? qui ne sont pas issus d'une même classe ? je ne comprends pas trop tes termes.

[Bousk]

Bonjour,

si je comprends ce que tu essayes de faire comprendre.. il s'agit du principe-même du polymorphisme (si je ne me trompe pas de terme).
Il suffit de faire de l'héritage et des fonctions virtuelles.

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
class CWeapon
{
public:
  virtual void tirer()=0;
};
class CM16 : public CWeapon
{
public:
  virtual void tirer() { std::cout<<"je tire au M16 !"<<std::endl; }
};
class CAK : public CWeapon
{
public:
  virtual void tirer() { std::cout<<"je tire au AK"<<std::endl; }
};
 
int main()
{
  std::vector<CWeapon*> vecWeapons;
  vecWeapons.push_back(new CM16());
  vecWeapons.push_back(new CAK());
  vecWeapons[0]->tirer(); // tir au M16
  vecWeapons[1]->tirer(); // tir au AK
 
  while (vecWeapons.size())
  {
    delete vecWeapons.back();
    vecWeapons.pop_back();
  }
}

[Kaamui]

c'est ce que j'essayais de faire comprendre oui. D'ailleurs je pensais (tu parlais de dynamic_cast) il y a un article qui peut surement t'intéresser qui résume tout ce que tu énonçais avec cette solution, ça pourra t'aider à prendre ta décision finale (j'imagine qu'il y a tout aussi bien sur ce site mais bon, là aussi, et puis les exemples me font rire ). Mais je ne doute pas que tu connaisse déjà bien tout cela, seulement ça peut en intéresser d'autres.

Cordialement,

l'article/tutoriel dont je parlais

[Fifou625]

merci oui ,en principe on utilise le polymorphisme dynamique en c++
je coderai avec