Liens entre des classes héritées

**qwiqwi** · 08/02/2006, 19h22

Bonjour,

Je débute en c++ et j'ai un problème que je n'arrive pas à résoudre. Je travaille avec dev c++ et en gros voici mon programme.

Gestion de comptes avec gestion des mouvements liés.
J'ai une pile template qui a des fonctions propres à la gestion d'un vecteur (d'objet ou de pointeurs) et j'ai dérivé de cette classe 2 autres classes, pileComptes et pileMouvement.
J'ai également une 3e classe dérivée de pile qui s'appelle pileMenu dans laquelle je fais appel aux routines qui gère les menus (loadés à partir de fichiers textes).

La question est la suivante, dans ma pileMenu, j'ai besoin d'appeler la pileCompte (lorsque je donne l'instruction de créer un compte et qu'il faut le stocker dans la pile) et là impossible d'indiquer dans l'entête du fichier que pileMenu à une référence à la fois vers pile.h et pileComptes.h; le compilateur râle en me disant que j'essaye de redéfinir la classe pile.

Comment faire une référence d'un objet dérivé d'une classe vers un autre objet dérivé de la même classe ?

Pour exemple un bout de code de pileMenu :

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
   switch (ichoix){
	case 0:
		exit(0);
		break;
	case 1:
        fflush(stdin);
		cout<<"\nCreer un compte\n";
		monCompte.RemplirCompte();
		pile_Comptes.Store(monCompte);
		chargerMenu("menu.txt");
		break;
	case 2:
        fflush(stdin);
		cout<<"\nImprimer les comptes\n";
		pile_Comptes.imprimerComptes();
		chargerMenu("menu.txt");
		break;

D'ou là référence vers pile_Comptes ....

Merci de votre aide

[ Balises [CODE] ajoutées par BigBoomShakala. Pensez à les utiliser, merci ]

**qwiqwi** · 09/02/2006, 01h08

J'ai tenté de virtualiser mes classes héritées mais rien à faire, la cohabitation de deux classes héritées d'un template ne fonctionne pas.

Quelqu'un a une idée ?

**Jan Rendek** · 09/02/2006, 09h41

Les fichiers d'entêtes sont-ils correctement protégés contre l'inclusion multiple ?
Sinon, quel est l'erreur retournée par le compilateur ?

**Blowih** · 09/02/2006, 11h21

Envoyé par VoidSeer

Les fichiers d'entêtes sont-ils correctement protégés contre l'inclusion multiple ?

+1
as tu mis dans tes .h des tes classe un truc du genre

Code :

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

1
2
3
4
5
6
7
8
9
#ifndef _maclasse_h_
#define _maclasse_h_
 
class maclasse
{
...
};
 
#endif

ça te permet d'evite les inclusions multiples

**qwiqwi** · 09/02/2006, 12h23

Je pense que oui voici le code du fichier menu qui doit faire appel aux deux classes héritées :

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
#ifndef PILEMENU_H
#define PILEMENU_H
#include "menu.h"
#include "pile.h"
#include "pileMouvements.h"
#include "pileComptes.h"
using namespace std;
/*
 * No description
 */
class pileMenu
{
    protected:
     pile<compte> pile_Comptes;
     pile<mouvement> pile_Mouvements;
    public:
        // class constructor
        pileMenu();
        // class destructor
        ~pileMenu();
        void chargerMenu(char nomfichier[20]);
        void choisirMenuPrincipal(int ichoix);
        void choisirMenuCompte(int ichoix);
        void choisirMenuMouvement(int ichoix);
};
 
#endif // PILEMENU_H

**qwiqwi** · 09/02/2006, 12h25

je précise que les 2 instanciations de pile<compte> et pile<mouvement> est la seule solution que j'ai trouvé pour accéder aux 2 piles mais le problème c'est que j'ai des fonctions propre à pilecompte et à pilemouvement que je n'arrive (forcément) pas à atteindre de cette façon.

**qwiqwi** · 09/02/2006, 13h11

j'ai tenté ceci

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
#ifndef PILEMENU_H
#define PILEMENU_H
#include "menu.h"
#ifndef PILE_H
#define PILE_H
#include "pile.h"
#endif
#ifndef PILEMOUVEMENTS_H
#define PILEMOUVEMENTS_H
#include "pileMouvements.h"
#endif
#ifndef PILECOMPTES_H
#define PILECOMPTES_H
#include "pileComptes.h"
#endif
 
using namespace std;
/*
 * No description
 */
class pileMenu
{
    protected:
     pileComptes pile_Comptes;
     pileMouvements pile_Mouvements;
    public:
        // class constructor
        pileMenu();
        // class destructor
        ~pileMenu();
        void chargerMenu(char nomfichier[20]);
        void choisirMenuPrincipal(int ichoix);
        void choisirMenuCompte(int ichoix);
        void choisirMenuMouvement(int ichoix);
};
 
#endif // PILEMENU_H

mais j'ai une erreur du compilateur qui me dit :
pileComptes does not name a type
idem pour pileMouvements ....

**Médinoc** · 09/02/2006, 13h34

Retire les #define qui précèdent chaque #include...

**Blowih** · 09/02/2006, 13h47

met plutot les #define dans les /h de chaque classe et non lors de l'include de celles-ci:

Code :

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

1
2
3
4
5
6
7
8
// pile.h
#ifndef _pile_h_
#define _pile_h_
 
class pile
{
};
#endif

Code :

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

1
2
3
4
5
6
7
8
9
// pileFille1.h
#ifndef _pile_fille1_h_
#define _pile_fille1_h_
 
#include "pile.h"
class pileFille1
{
};
#endif

**qwiqwi** · 09/02/2006, 14h02

non, ça ne donne rien, même erreur, voici les fichiers pilecomptes et pilemouvements

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
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
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
// Class automatically generated by Dev-C++ New Class wizard
 
#ifndef PILEMOUVEMENTS_H
#define PILEMOUVEMENTS_H
#include "pile.h" // inheriting class's header file
 
using namespace std;
/*
 * No description
 */
class pileMouvements : public virtual pile<mouvement>
{
	public:
		// class constructor
		pileMouvements();
		// class destructor
		~pileMouvements();
};
 
#endif // PILEMOUVEMENTS_H
 
#ifndef PILECOMPTES_H
#define PILECOMPTES_H
#include "compte.h"
#include "pile.h"
using namespace std;
/*
 * No description
 */
class pileComptes :public virtual pile<compte>
{
	public:
		// class constructor
		pileComptes();
		// class destructor
		~pileComptes();
};
 
#endif // PILECOMPTES_H
 
et le fichier pileMenu
#ifndef PILEMENU_H
#define PILEMENU_H
#include "menu.h"
#ifndef PILEMOUVEMENTS_H
#include "pileMouvements.h"
#endif
#ifndef PILECOMPTES_H
#include "pileComptes.h"
#endif
using namespace std;
/*
 * No description
 */
class pileMenu
{
    protected:
     //pile<compte> pile_Comptes;
     //pile<mouvement> pile_Mouvements;
    pileComptes pile_Comptes;
    public:
        // class constructor
        pileMenu();
        // class destructor
        ~pileMenu();
        void chargerMenu(char nomfichier[20]);
        void choisirMenuPrincipal(int ichoix);
        void choisirMenuCompte(int ichoix);
        void choisirMenuMouvement(int ichoix);
};
 
#endif // PILEMENU_H
voici la pile 
#include "iostream"
#include <conio.h>
#include <string.h>
#include <math.h>
#include "compte.h"
#include "mouvement.h"
using namespace std;
//======================================================================
//  Déclaration de la classe
//======================================================================
 
 template <class liste> class pile
{
 protected :
	liste *vect;                                     // pointeur sur la "base" de la pile de listes
	int	 nelem;                                      // nombre d'éléments dans la pile                              
	int	 idx;                                        // index sur le dernier élément de la pile
	int	 incr;                                       // incrément de la taille de la pile
	int  ierr;                                       // indicateur d'erreur
	liste xerr;                                      // variable d'erreur
 
	static long pcount;                              // comptecourant les piles de listes
	void	Initialize (void);                       // fonction inaccessible de l'extérieur
 
 public :
    pile	   (void);                      // constructeur
    pile       (const pile<liste> & Source);
    virtual ~pile	   (void);                      // destructeur
 
    int Store(const liste f);                       // stockage dans la pile
    liste& Get(void);                               // lecture du dernier élément
    liste& Get(const int i);                        // lecture d'un élément quelconque
    int getIdpile(void);
    int Remove(void);                               // suppression du dernier élément
    int Remove(const int i);                        // suppression d'un élément quelconque
    void Flush(void);                               // nettoyage de la pile
    int Count(void);                                // comptecourant le nombre d'éléments
    int IsError(void);                              // renvoie l'indicateur d'erreur
    pile<liste>& operator=  (const pile<liste>& source);    // copie de la pile
    pile<liste>& operator+= (const pile<liste>& Source);    // concaténation de piles
    pile<liste> operator+  (const pile<liste>& Source);    // concaténation dans un autre pile
    liste& operator[] (const int i);                       // lecture d'un élément quelconque
    void imprimerComptes(void);          
    void imprimerMouvements(void);          
};
 
//======================================================================
//  Implémentation de la classe
//======================================================================
template <class liste>    int pile<liste>::getIdpile(void)
{
         return(idx);
}
//----------------------------------------------------------------------
template <class liste>    pile<liste>::pile(void)
{
 cout<<"Appel " << ++pcount << " du constructeur\n";
 Initialize();
}
 
//----------------------------------------------------------------------
 
template <class liste>    pile<liste>::pile (const pile<liste> & Source)
{
 if (this==&Source) return;                     // A=A ?
 
 cout<<"Appel " << ++pcount << " du constructeur\n";
 Initialize();
 
 if (Source.idx < 0) return;                    // pile source vide
 
 int nsize = (Source.idx/incr + 1) * incr;      // allouer un multiple de incr
 vect = new liste [nsize];
 
 ierr = !vect;                                  // allocation ok?
 if (ierr) return;                              // non
 
 nelem = nsize;                                 // oui, alors copier
 memcpy (vect, Source.vect, nelem*sizeof(liste));
 idx=Source.idx;
 return;
}
 
//----------------------------------------------------------------------
 
template <class liste>    pile<liste>::~pile(void)
{
 cout<<"Appel " << pcount-- << " du destructeur\n";
 Flush();
}
 
//----------------------------------------------------------------------
 
template <class liste> void pile<liste>::Initialize(void)
{
 vect  = NULL;
 nelem = 0   ;
 idx   =-1   ;
 incr  = 16  ;
 ierr  = 0   ;      // pas d'erreur au départ
 memset (&xerr, 0, sizeof(liste) );
}
 
//----------------------------------------------------------------------
 
template <class liste> int pile<liste>::Store(const liste f)
{
 cout <<"\nonrentre dans le store\n";
 ierr = !(idx < 0x7FFF);        // l'indice peut-il être incrémenté ?
 if (ierr) return (ierr);
 
 if (idx >= nelem-1)	        // pile pleine ?
    {
     cout << "Allongement du vecteur\n";
 
     liste *vbis;
     nelem+=incr;
     vbis=new liste[nelem];
     if (!vbis) return(ierr=-1);     // erreur d'allocation ?
 
     memcpy(vbis, vect, (idx+1)*sizeof(liste));
     delete [] vect;
     vect = vbis;
    }
 
 vect[++idx]=f;
 cout << "Valeur stockee en [" << idx << "]\n";
 return(ierr=0);
}
 
//----------------------------------------------------------------------
 
template <class liste> liste& pile<liste>::Get(void)
{
 ierr = (idx<0);
 if (ierr) return (xerr);
 return (*(vect+idx));
}
 
//----------------------------------------------------------------------
 
template <class liste> liste& pile<liste>::Get(const int i)
{
 //cout<<"\non rentre dans le get\n";
 ierr = ((i<0) || (i>idx) || (idx<0));
 if (ierr) return (xerr);
 return (*(vect+i));
 
}
 
//----------------------------------------------------------------------
 
template <class liste> int pile<liste>::Remove(void)
{
 ierr = (idx<0);
 if (!ierr)
     cout << "Element [" << idx-- << "] détruit\n";
 return(ierr);
}
 
//----------------------------------------------------------------------
 
template <class liste> int pile<liste>::Remove(const int i)
{
 ierr = ((i<0) || (i>idx) || (idx<0));
 if (!ierr)
    {
     memmove(vect+i, vect+i+1, (idx-i)*sizeof(liste));
     cout << "Element [" << i << "] detruit\n";
     idx--;
    }
 return(ierr);
}
 
//----------------------------------------------------------------------
 
template <class liste> inline int pile<liste>::Count(void)
{
 return (ierr=0, idx+1);
}
 
//----------------------------------------------------------------------
 
template <class liste> inline int pile<liste>::IsError(void)
{
 return (ierr);
}
 
//----------------------------------------------------------------------
 
template <class liste> void pile<liste>::Flush(void)
{
 cout << "Purger la pile\n";
 if (vect) delete [] vect;
 Initialize();
}
 
//----------------------------------------------------------------------
 
template <class liste> pile<liste> & pile<liste>::operator= (const pile<liste> & Source)
{
 if (this==&Source) return(*this);          // A=A ?
 Flush();				                    // vider la pile courante
 
 if (Source.idx < 0) return(*this);         // pile source vide
 
 int nsize = (Source.idx/incr + 1) * incr;  // allouer un multiple de incr
 vect = new liste [nsize];
 
 ierr = !vect;                              // allocation ok?
 if (ierr) return(*this);                   // non
 
 nelem = nsize;                             // oui, alors copier
 memcpy (vect, Source.vect, nelem*sizeof(liste));
 idx=Source.idx;
 return(*this);
}
 
//----------------------------------------------------------------------
 
template <class liste> pile<liste>& pile<liste>::operator+= (const pile<liste> & Source)
{
 if (Source.idx < 0) return(*this);     // pile source vide
 
 int ndx     = idx+Source.idx+1;
 int nsize   = (ndx/incr + 1) * incr;   // allouer un multiple de incr
 liste *vbis = new liste [nsize];
 
 ierr = !vect;                          // allocation ok?
 if (ierr) return(*this);               // non
 
					// copier les données de *this
 memcpy(vbis, vect, (idx+1)*sizeof(liste));
					// superposer les données de Source
 memcpy(vbis+idx+1, Source.vect, (Source.idx+1)*sizeof(liste));
 
 delete [] vect;
 vect = vbis;
 nelem= nsize;
 idx  = ndx;
 
 return(*this);
}
 
//----------------------------------------------------------------------
 
template <class liste> pile<liste> pile<liste>::operator+ (const pile<liste> & Source)
{
 pile<liste> pile_X = *this;
 pile_X += Source;
 return (pile_X);       // ici, il y a création d'un objet temporaire
}
 
//----------------------------------------------------------------------
 
template <class liste> liste& pile<liste>::operator[] (const int i)
{
 ierr = ((i<0) || (i>idx) || (idx<0));
 if (ierr) return (xerr);
 return (*(vect+i));
}
 
//======================================================================
//  Initialisation de la variable statique
//======================================================================
 
template <class liste> long pile<liste>::pcount=0;
 
 //********************************************************

Dès que j'essaye d'inclure les 2 classes dérivées de pile dans le même fichier, il m'indique que j'essaye de redéfinir la classe pile

**Blowih** · 09/02/2006, 14h54

Dès que j'essaye d'inclure les 2 classes dérivées de pile dans le même fichier, il m'indique que j'essaye de redéfinir la classe pile

c'est parce que aparament tu na pas mis

Code :

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

1
2
3
4
5
6
#ifndef _pile_h_
#define _pile
class pile
{
};
#endif

dans ta classe de template de pile

**qwiqwi** · 09/02/2006, 15h49

En fait comme ma class pile est une classe template, tout est dans un point h
j'ai quand même essayé ton idée, mais ça ne fonctionne décidément pas.

Merci de ton aide !

Si tu as d'autres idées n'hésite pas, je bloque toujours et j'ai tout mis dans pile.h ce qui est triste

**Jan Rendek** · 09/02/2006, 16h36

Je sais que cela ne résoud pas le problème, mais pourquoi vouloir dériver de pile ?
J'ai du mal à saisir l'intérêt.
Ensuite, quelle est le libéllé de l'erreur de compilation ? Dans quel fichier, et à quelle ligne apparaît-elle ?

Liens entre des classes héritées

C++

Discussions similaires

Partager

Partager