Créer une classe dans une classe

Version imprimable

02/06/2007, 10h22
FabaCoeur

Créer une classe dans une classe

Bonjour,

Je voudrais créer une classe imbriquée dans une autre, je m'explique sur un exemple; pour la classe std::list, on peut déclarer un itérateur de la manière suivante:

std::list::iterator UnIterateur;

Comme si iterator est une classe interne à la classe liste. Et grâce à cela, je peux utiliser la classe std::list dans un programme et créer à coté une classe iterator sans qu'il n'y ai de conflit de nom.

Merci pour vos futures réponses ;)
02/06/2007, 10h39
Elay

Et c'est quoi ton problème?

Code:

1
2
3
4
5
6
7
class Classe
{
    class Imbriquee
    {
 
    };
};

02/06/2007, 11h51
FabaCoeur

Erf ok je pensais pas que c'étais possible, je l'ai vu dans aucun cours...
Bon bah heu désolé pour ce ropic un peu inutile au final :lol:

:resolu:

Bah bah finalement ca n'a pas l'air si simple et évident que ça !
Pour faire des tests avec les réponses que vous m'avez apporté, j'ai commencé à faire une classe Liste à titre de test. J'ai commencé de la manière suivante:
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 #ifndef LISTE_H #define LISTE_H template<class T> class Liste { public: class Cellule { public: T info; // La ligne suivante génère une erreur Liste<T>::Cellule *suivante; }; Liste(); ~Liste(); }; template<class T> Liste<T> :: Liste() { } template<class T> Liste<T> :: ~Liste() { } #endif
La ligne comportant Liste<T>::Cellule me génère une erreur (de syntaxe).
Qu'ai-je fais faux ?

02/06/2007, 17h16
Sylvain Togni

En règle générale il faudrait mettre

Code:

typename Liste<T>::Cellule *suivante;

pour indiquer au compilateur que Liste<T>::Cellule est un type.

Mais ici Liste<T>:: n'est pas obligatoire vu qu'on est à l'intérieur de la classe Liste. Donc jute

Code:

Cellule *suivante;
02/06/2007, 17h29
FabaCoeur

Cela semble fonctionner, mais une question me vient à l'esprit:
Comment est ce que l'on va différentier la classe Cellule contenue dans la classe Liste à celle qu'on aurait pu définir dans le main? Est ce que la classe Liste peut contenir des classes Cellule différentes des siennes (déclarée à l'extérieur d'elle même)? Comment lever l'ambiguité?

Il faut donc utiliser la première syntaxe, mais si on fait la seconde qu'est ce qui nous dit qu'il n'y a pas déjà une classe Cellule de déjà définie lors de l'inclusion du liste.h ?
02/06/2007, 18h47
Sylvain Togni

Si une autre classe Cellule existe en dehors de la classe Liste<T>, ça n'a pas d'importance, l'identifiant "Cellule" à l'intérieur de la classe Liste<T> sera toujours équivalent à Liste<T>::Cellule. La classe Cellule exterieure pourra être utilisée via "::Cellule", les "::" signifiants que l'identifant est à chercher dans le namespace global.
02/06/2007, 18h58
FabaCoeur

Ok, je ne savais pas que l'on pouvait faire ::Cellule sans rien mettre devant.
Merci beaucoup pour toutes ces présisions :king:

Voila un exemple de source que j'ai fait en rapport avec le sujet, il s'agit d'une classe Pile très basique (équivalente à la classe std::stack de la STL). Le conteneur Cellule y est déclaré à l'intérieur:

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
/* -------------------------------------
   Class Pile - pile.h
   par MUGUET Fabien
   créé le 02/05/2007
   dernière modif le 02/05/2007
   ------------------------------------- */
 
 
#ifndef PILE_H
#define PILE_H
 
 
	// -----------------------------
	// Classe Pile
	// -----------------------------
 
	template<class T>
	class Pile {
 
		private:
 
			class Cellule {
				public:
					T info;
					Cellule *suivante;
 
					Cellule(T info, Cellule *suivante = NULL) : info(info), suivante(suivante) { };
					Cellule(Cellule *suivante = NULL) : suivante(suivante) { };
					Cellule( const Cellule &c ) : info(c.info), suivante(c.suivante) { };
			};
 
 
		public:
 
			Pile();
			Pile( const Pile &p );
			~Pile();
 
			bool est_vide();
			int taille();
 
			void empiler(T info);
			T depiler();
 
			T lire_sommet();		
 
 
		private:
 
			Cellule *sommet;
			int nbelt;
 
	};
 
 
 
	// -----------------------------
	// Constructeurs / Destructeur
	// -----------------------------
 
	// Constructeur simple
	template<class T>
	Pile<T> :: Pile() : sommet(NULL), nbelt(0) { }
 
	// Constructeur par recopie
	template<class T>
	Pile<T> :: Pile( const Pile<T> &pile ) : sommet(NULL), nbelt(0) {
 
		Pile<T> temp;
		Cellule *p = pile.sommet;
 
		while( p != NULL ) {
			temp.empiler(p->info);
			p = p->suivante;
		}
 
		while( !temp.est_vide() )
			this->empiler( temp.depiler() );
	}
 
	// Destructeur
	template<class T>
	Pile<T> :: ~Pile() {
 
		while( !this->est_vide() )
			this->depiler();
	}
 
 
 
	// -----------------------------
	// Fonctions publiques
	// -----------------------------
 
	// Indique si la pile est vide
	template<class T>
	bool Pile<T> :: est_vide() {
		return (this->sommet == NULL);
	}
 
	// Retourne le nombre d'élément enregistré
	template<class T>
	int Pile<T> :: taille() {
		return this->taille;
	}
 
	// Empiler
	template<class T>
	void Pile<T> :: empiler(T info) {
 
		Cellule *p = new Cellule(info, this->sommet);
		this->sommet = p;
		this->nbelt++;
	}
 
	// Depiler
	template<class T>
	T Pile<T> :: depiler() {
 
		T mem = this->sommet->info;
		this->sommet = this->sommet->suivante;
		this->nbelt--;
		return mem;
	}
 
	// Retourne la valeur du sommet
	template<class T>
	T Pile<T> :: lire_sommet() {
 
		return this->sommet->info;
	}
 
 
#endif