Classe B imbriquées dans A

Bonjour,

J'ai eu beau beaucoup cherché, je n'ai pas trouvé la solution a cette question... J'ai deux classe, A et B et je voudrais les definir de cette façon:

Citation:

Classe A
{
prive:
...
public:
....
Classe B
{
...
};
};

Apparament la syntaxe n'est pas la bonne, car cela me genere des erreurs que je n'avais pas avant de les imbriquées. de meme, je me demandais comment il fallait les nommer lors de leur definission? Si vous pouviez m'aider

merci beaucoup

Tu peux nous donner le code exact sur lequel tu veux qu'on commente. Parce que quand je vois classe et prive...

Le code est assez consequent, il genere plusieurs centaine de ligne, mais j'ai réussi a cerner le probleme. Il ne vient pas de l'inclusion lui meme mais dut faut que chacune des deux classes est un patron.On a:

Citation:

template <classe T> classe A
{
public:
template <classe T> classe B
{...};
};

Du fait que A est template, faut il preciser que B l'est aussi?

Merci

Ma boule de cristal est en panne... Donne un exemple minimal qui reproduise ton problème.

Le plus simple est que je te donne une partie de mon code, j'ai essayé de mettre l'essentiel:
ci joint le squelette de classe:

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
template <class T> class Iterateur;
 
template <class T> class Liste
{
 
private:
   // pointeurs vers le premier et le dernier element
   Element<T>* premier;
   Element<T>* dernier;
 
   void coppy(const Liste&);  //Copie une liste
   void free();       // supprime une liste
 
public:
       class Iterateur
        {
         public:
   // constructeur
   Iterateur();
 
   // retourne la valeur dans cette position
   T& operator *() const;
 
   // avance a la position suivante
   void operator ++ ();
 
   // recule a la position precedente
   void operator -- ();
 
   // compare deux iterateurs pour voir si ils sont égaux
   bool operator ==(const Iterateur& b) const;
 
   // Compare si deux iterateurs pour voir si ils sont differents
   bool operator !=(const Iterateur& b) const;
 
   //private:
   // pointeur vers l'element courant
   Element<T>* position;
 
   // pointeur vers le dernier element de la liste
   Element<T>* dernier;
  // friend class Liste <T>;
   };
 
   // constructeur
   Liste();
 
   // constructeur par recoppie
   Liste (Liste&);
 
   //destructeur
   ~Liste();
 
   // ajouter s a la fin de la liste
   void ajouter(const T& s);
 
   // ajouter s avant la position pos
   void inserer(const Iterateur& pos, const T& s);
 
   // supprimer l'element a la position pos
   void supprimer(Iterateur& pos);
 
   // la premiere position
   Iterateur debut() const;
 
   // la fin de la liste (apres la derniere position)
   Iterateur fin() const;
 
    // operateur d'affectation
   Liste& operator = (const Liste&);
 
      };
 
#endif

Et voici le fichier liste.cpp

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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
template <class T> class Element
{
public:
   // constructeur
   Element(const T& s);
 
private:
   T valeur;
 
   // pointeurs vers les voisins
   Element* precedent;
   Element* suivant;
 
friend class Liste <T>;
friend class Liste <T>::Iterateur;
//friend class Iterateur;
};
 
 
template <class T> Element <T>::Element  (const T& s)
{  valeur = s;
   precedent = suivant = NULL;
}
 
 
template <class T> Liste <T> ::Iterateur::Iterateur()
{  position = dernier = NULL;
}
 
template <class T> T& Liste<T>::Iterateur::operator* () const
{
   return position->valeur;
}
 
template <class T> void Liste<T>::Iterateur::operator ++ ()
{  position = position->suivant;
}
 
template <class T> void Liste <T>:: Iterateur ::operator -- ()
{  if (position == NULL) // fin de la liste
      position = dernier;
   else
      position = position->precedent;
}
 
template <class T> bool Liste <T>::Iterateur ::operator ==(const Iterateur& b) const
{  return position == b.position;
}
 
template <class T>  bool Liste <T>:: Iterateur ::operator !=(const Iterateur& b) const
{  return position != b.position;
}
 
 
template <class T> Liste <T> ::Liste()
{  premier = dernier = NULL;
}
 
 
template <class T> Iterateur Liste <T>::debut() const
{  Iterateur  it;
   it.position = premier ;
   it.dernier = dernier;
   return it;
}
 
 
template <class T> Iterateur Liste <T>::fin() const
{  Iterateur  it;
   it.position = NULL;
   it.dernier = dernier;
   return it;
}
 
template <class T>  void Liste <T>::ajouter(const T &s)
 {
   Element <T>*nouveau = new Element <T>(s);
   if(dernier==NULL)
   {
    premier=dernier=nouveau;
   }
   else {
    nouveau->precedent=dernier;
	 dernier->suivant=nouveau;
	 dernier=nouveau;
	 }
  }
 
  template <class T> void Liste <T>::inserer(const Iterateur &pos, const T &s)
  {
   Element <T> *nouveau = new Element <T>(s);
   Element <T> *p=pos.position;
   Element <T>*precedent=p->precedent;  //contenu de p->precedent
 
   if(p==NULL)
   {premier=dernier=nouveau;}
 
   else{
       p->precedent=nouveau;
        nouveau->precedent=precedent;
	nouveau->suivant=p;
	precedent->suivant=nouveau;
	   }
   }
 
  template <class T> void Liste <T>::supprimer(Iterateur &pos)
   {
   Element <T> *p=pos.position;
   Element <T>*precedent=p->precedent;
   Element <T> *suivant=p->suivant;
 
   if(p==NULL)
   {premier=dernier=p;}
 
   else{
        precedent->suivant =suivant;
	suivant->precedent=precedent;
	}
   delete(p);
   }
 
   template <class T> void Liste <T>::coppy(const Liste &L)
   {
   premier=dernier=NULL;
   for(Iterateur it  =L.debut();it!=L.fin();it++)
    {
    ajouter(*it);
    }
   }
 
   template <class T> void Liste <T> ::free()
   {
   for(Iterateur it =debut();it!=fin();it++)
   {
    supprimer(it);
   }
   }
 
   template <class T> Liste <T> ::~Liste()
   {
    free();
   }
 
   template <class T> Liste <T>::Liste(Liste &l)
   {
     coppy(l);
   }
 
   template <class T> Liste& Liste <T>:: operator = (const Liste &l)
   {
   if(this!=&l)
   {
   free();
   coppy (l);
   }
   return *this;
   }

ET en déclarant ta classe imbriquée 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
template <class T> class Iterateur;
 
template <class T> class Liste
{
 
private:
   // pointeurs vers le premier et le dernier element
   Element<T>* premier;
   Element<T>* dernier;
 
   void coppy(const Liste&);  //Copie une liste
   void free();       // supprime une liste
 
public:
       class Iterateur<T>
        {
         public
//etc..

Je viens d'essayer et cela me genere une erreur.

Avant de les imbriquer, class Iterateur et class Liste etait definit de la meme façon et le programme tourné.
Mais il semblerait que le fait d'imbriquer Iterateur dans Liste enleve le template a la classe Iterateur. Mais du coup j'ai des probleme d'accesibilté. J'ai des erreurs du type: "Iterateur::postion is not accessible".

J'ai essayer de mettre en public tt ce qui est en privé et cela ne change rien, donc a priori ce n'est pas un probleme d'accesseur!

Il faut utiliser le mot-clé typename pour accéder à un type défini dans une classe template.
Code:

1 2 3 4 template<class T> typename Liste<T>::Iterateur Liste<T>::debut() const { //... }