Discussion :

[FabaCoeur]

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

[Elay]

Et c'est quoi ton problème?

[Laurent Gomila]

Code :

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

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

[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

[FabaCoeur]

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 :

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
#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 ?

[Sylvain Togni]

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

Code :

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

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 :

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

Cellule *suivante;

[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 ?

[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.

[FabaCoeur]

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

[FabaCoeur]

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 :

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
/* -------------------------------------
   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