Problème de Template c++

Version imprimable

Je comprend vraiment pas quoi faire avec mon erreur mrd,

voici ma class :

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
#pragma once
#include <iostream>
#include <string>
using namespace std;
 
#define null 0
 
template <class Objet>
class Noeud
{
    typedef Noeud<Objet>* NoeudPtr;
 
    NoeudPtr gauche;
    NoeudPtr droite;
    Objet _objet;
 
public :
 
    Noeud<Objet>(Objet objet)
    {
      _objet = new Objet(objet); // <-- Mon Erreur est Ici impossible de cast                    //int * en int
      gauche = null;
      droite = null;
    }
 
    ~Noeud<Objet>()
    {
      delete _objet;
    }
 
    void Affiche()
    {
 
    }
 
    void Lister()
    {
 
    }
 
    void Inserer(Objet objet)
    {
      if(objet < this->_objet)
         if(gauche)
            gauche->Inserer(objet);
         else
            gauche = new Noeud(objet);
      else
         if(droite)
            droite->Inserer(objet);
         else
            droite = new Noeud(objet);
    }
 
    Objet Maximum()
    {
      NoeudPtr MaxNoeud = this;
 
      while(MaxNoeud->droite)
      {
         MaxNoeud = MaxNoeud->droite;
      }
      return MaxNoeud->_objet;
    }
 
    Objet Minimum()
    {
      NoeudPtr MinNoeud = this;
 
      while(MinNoeud->gauche)
      {
         MinNoeud = MinNoeud->gauche;
      }
      return MinNoeud->_objet;
    }
 
    NoeudPtr Minimum(NoeudPtr& perePtr)
    {
      NoeudPtr MinNoeud = this;
 
      while(MinNoeud->gauche)
      {
         perePtr = MinNoeud;
         MinNoeud = MinNoeud->gauche;
      }
      return MinNoeud;
    }
 
    NoeudPtr Maximum(NoeudPtr& perePtr)
    {
      NoeudPtr MaxNoeud = this;
 
      while(MaxNoeud->droite)
      {
         perePtr = MaxNoeud;
         MaxNoeud = MaxNoeud->droite;
      }
      return MaxNoeud;
    }
 
    bool Feuille()
    {
 
    }
 
    bool Gauche(NoeudPtr perePtr)
    {
 
    }
 
    bool Droite(NoeudPtr perePtr)
    {
 
    }
 
    long Nb_Noeuds()
    {
 
    }
 
    long Nb_Niveux()
    {
 
    }
 
    NoeudPtr Cherche(Objet objet)
    {
 
    }
 
    NoeudPtr Pere(NoeudPtr noeudPtr)
    {
 
    }
 
    void Retirer(Objet objet)
    {
 
    }
 
    void Retirer(NoeudPtr noeudPtr)
    {
 
    }
};

main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include "Noeud.h"
#include <string>
using namespace std;
 
int main()
{
   Noeud<int> racine(50);
   racine.Inserer(25);
   racine.Inserer(12);
   racine.Inserer(33);
   racine.Inserer(75);
   racine.Inserer(55);
   racine.Inserer(80);
   racine.Retirer(50);
   racine.Retirer(racine.Maximum());
   racine.Retirer(racine.Minimum());
   cout << "Nombre de noeuds : " << racine.Nb_Noeuds() << endl;
   cout << "Nombre de niveaux : " << racine.Nb_Niveux() << endl;
   racine.Lister();
   system("pause");
   return 0;
}

Si j'essaye de déclarer ma variable private dans ma classe Objet _objet en

pointeur : Objet* _objet j'ai des erreurs quand je veux comparer mes objets : if(objet < this->_objet)

24/11/2011, 05h57
screetch

Code:

_objet = objet;

peut etre?
24/11/2011, 08h23
Bousk

Bonjour,

pourquoi faire un new pour un simple int ?

Code:

_objet = objet

est amplement suffisant.
24/11/2011, 09h55
ZiGoM@r

Citation:

Envoyé par lolaalol

Si j'essaye de déclarer ma variable private dans ma classe Objet _objet en

pointeur : Objet* _objet j'ai des erreurs quand je veux comparer mes objets : if(objet < this->_objet)

Tu compareras alors leurs adresses et non leurs valeurs, oublis cette idée. Remplaces juste "_object = new Object(object);" par "_object = object;"
Tu n'auras donc pas besoin du "delete _objet" dans le destructeur, par contre, n'oublis pas d'y détruire les nœuds gauche et droite !
Ensuite, passes tes paramètres par référence : "Inserer (Objet objet)" devient "Inserer (Objet const & objet)" par exemple.
Aussi, préfères "objet_" à "_objet", le préfixe "_" est strictement réservé à l'implémentation de la bibliothèque standard et au compilateur.
Enfin, "Noeud" est un nom beaucoup trop générique, préfères le "Set" de la bibliothèque standard (qui remplit le même rôle), "SetNode" pour quelque chose de plus spécifique, voir "BST" ou "BST_Node" (ABR en français).
24/11/2011, 09h57
darkman19320

Salut,
Tu veux faire un new sur une référence et non un pointeur.
Change:

Code:

Objet _objet;

en :

Code:

Objet* _objet

++
24/11/2011, 14h03
lolaalol

Citation:

Envoyé par ZiGoM@r

Tu compareras alors leurs adresses et non leurs valeurs, oublis cette idée. Remplaces juste "_object = new Object(object);" par "_object = object;"
Tu n'auras donc pas besoin du "delete _objet" dans le destructeur, par contre, n'oublis pas d'y détruire les nœuds gauche et droite !
Ensuite, passes tes paramètres par référence : "Inserer (Objet objet)" devient "Inserer (Objet const & objet)" par exemple.
Aussi, préfères "objet_" à "_objet", le préfixe "_" est strictement réservé à l'implémentation de la bibliothèque standard et au compilateur.
Enfin, "Noeud" est un nom beaucoup trop générique, préfères le "Set" de la bibliothèque standard (qui remplit le même rôle), "SetNode" pour quelque chose de plus spécifique, voir "BST" ou "BST_Node" (ABR en français).

Pourquoi je dois détruire NoeudPtr gauche et droite ? se sont juste des pointeurs, je ne leurs allouent pas de mémoire dans le tas. non ?
24/11/2011, 15h15
Bousk

A partir du moment où tu as un new, tu alloues de la mémoire, et il faut la libérer, en détruisant l'objet en question.

J'ai résolu tout voici le code :

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
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
#include <iostream>
using namespace std;
 
template<class Objet>
class Noeud
{
	typedef Noeud<Objet>* NoeudPtr;
 
	NoeudPtr gauche;
	NoeudPtr droite;
	Objet objet;
 
public:
	Noeud<Objet>(Objet objet)
	{
		this->objet = objet;
		gauche = NULL;
		droite = NULL;
	}
	// Destruction des noeuds
	~Noeud<Objet>()
	{
		delete gauche;
		delete droite;
	}
	void Affiche()
	{
		cout << objet << endl;
	}
	void Lister()
	{
		if(gauche)
		{
			gauche->Lister();
		}
 
		Affiche();
 
		if(droite)
		{
			droite->Lister();
		}
	}
	// On insere un nouvel objet
	void Inserer(Objet objet)
	{
		// Si le nouvel objet est plus petit que la racine
		if(objet < this->objet)
		{
			// S'il y a déjà un noeud à gauche on l'insere, sinon on cree un nouveau noeud
			if(gauche)
			{
				gauche->Inserer(objet);
			}
			else
			{
				gauche = new Noeud(objet);
			}
		}
		else
		{
			// S'il y a déjà un noeud à droite on l'insere, sinon on cree un nouveau noeud
			if(droite)
			{
				droite->Inserer(objet);
			}
			else
			{
				droite = new Noeud(objet);
			}
		}
	}
	Objet Maximum()
	{
		if(droite)
		{
			return droite->Maximum();
		}
		else
		{
			return objet;
		}
	}
	Objet Minimum()
	{
		if(gauche)
		{
			return gauche->Minimum();
		}
		else
		{
			return objet;
		}
	}
	NoeudPtr Minimum(NoeudPtr& perePtr)
	{
		if(perePtr->gauche)
		{
			return Maximum(perePtr->gauche);
		}
		else
		{
			return perePtr;
		}
	}
	NoeudPtr Maximum(NoeudPtr& perePtr)
	{
		if(perePtr->droite)
		{
			return Maximum(perePtr->droite);
		}
		else
		{
			return perePtr;
		}
	}
	bool Feuille()
	{
		if(gauche || droite)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
	bool Gauche(NoeudPtr perePtr)
	{
		return (this == perePtr->gauche);
	}
	bool Droit(NoeudPtr perePtr)
	{
		return (this == perePtr->droite);
	}
	long Nb_Noeuds()
	{
		long Compte = 1;
 
		if(gauche)
		{
			Compte += gauche->Nb_Noeuds();
		}
		if(droite)
		{
			Compte += droite->Nb_Noeuds();
		}
 
		return Compte;
	}
	long Nb_Niveux()
	{
		long Nb_Gauche = 0;
		long Nb_Droite = 0;
 
		if(gauche)
		{
			Nb_Gauche = gauche->Nb_Niveux();
		}
		if(droite)
		{
			Nb_Droite = droite->Nb_Niveux();
		}
 
		if (Nb_Gauche > Nb_Droite)
		{
			return(Nb_Gauche+1);
		}
		else 
		{
			return(Nb_Droite+1);
		}
 
	}
	NoeudPtr Cherche(Objet objet)
	{
		if(objet == this->objet)
		{
			return this;
		}
		if(objet < this->objet)
		{
			if(gauche)
			{
				return gauche->Cherche(objet);
			}
			else
			{
				return NULL;
			}
		}
		else
		{
			if(droite)
			{
				return droite->Cherche(objet);
			}
			else
			{
				return NULL;
			}
		}      
	}
	NoeudPtr Pere(NoeudPtr noeudPtr)
	{
		if(this == noeudPtr)
		{
			return NULL;
		}
 
		if(noeudPtr->Gauche(this) || noeudPtr->Droit(this))
		{
			return this;
		}
		else
		{
			if(noeudPtr->objet < objet)
			{
				if(gauche)
				{
					return gauche->Pere(noeudPtr);
				}
				else
				{
					return NULL;
				}
			}
			else
			{
				if(droite)
				{
					return droite->Pere(noeudPtr);
				}
				else
				{
					return NULL;
				}
			}
		}
	}
	void Retirer(Objet objet)
	{
		Retirer(Cherche(objet));
	}
	void Retirer(NoeudPtr noeudPtr)
	{
		NoeudPtr ptrMax = NULL;
		NoeudPtr ptrMin = NULL;
		if(noeudPtr != NULL)
		{
			if(this->objet != noeudPtr->objet)
			{
				if(!noeudPtr->Feuille())
				{
					if(noeudPtr->objet > this->objet)
					{
						ptrMax = noeudPtr->gauche->Maximum(noeudPtr->gauche);
						noeudPtr->objet = ptrMax->objet;
 
						if(ptrMax->Feuille())
						{
							 delete noeudPtr->gauche;
							 noeudPtr->gauche = NULL;
						}
						else
						{
							  noeudPtr->gauche = ptrMax->gauche;
							  ptrMax->gauche = NULL;
							  delete ptrMax;
						}
					}
					else
					{
						ptrMin = noeudPtr->droite->Minimum(noeudPtr->droite);
						noeudPtr->objet = ptrMin->objet;
 
						if(ptrMin->Feuille())
						{
						  delete noeudPtr->droite;
						  noeudPtr->droite = NULL;
						}
						else
						{
							 noeudPtr->droite = ptrMin->droite;
							 ptrMin->droite = NULL;
							 delete ptrMin;
						}
					}
				}
				else
				{
					if(noeudPtr->Gauche(Pere(noeudPtr)))
					{
						Pere(noeudPtr)->gauche = NULL;
					}
					else if(noeudPtr->Droit(Pere(noeudPtr)))
					{
						Pere(noeudPtr)->droite = NULL;
					}
					delete noeudPtr;
				}
			}
		}
	}
};

28/11/2011, 11h18
ZiGoM@r

Tout a l'air correct. Je réitère cependant ma remarque sur le passage des "objets" en paramètre par références : Si je manipule un Noeud<ObjectTresLourd>, mon ObjetTresLourd sera copié inutilement dans le constructeur de Noeud et à l'appel de Inserer. Idem pour le type de retour de Minimum et de Maximum.
Il te suffit de remplacer le paramètre "Objet objet" par "Objet const & objet" et "Objet Maximum()" par "Object const & Maximum()", etc..
C'est moins lisible et un peu plus compliqué, c'est C++... [/provoc]

Par contre, tu peux remplacer "NoeudPtr Maximum(NoeudPtr& perePtr)" par "NoeudPtr Maximum(NoeudPtr perePtr)".
Aussi, cette fonction devrait soit être static, soit être un vrai fonction membre (this remplacant le paramètre perePtr).

Bonne continuation (AVL, tas, etc.. que du bonheur !).
28/11/2011, 13h31
3DArchi
Salut,
Citation:
Envoyé par lolaalol

Code:

1 2 3 4 5 6 // Destruction des noeuds ~Noeud<Objet>() { delete gauche; delete droite; }
Je serais surpris que cela ne plante pas... Question ingénue :roll: : que va-t-il se passer dans le destructeur de gauche avec le pointeur droite et vice-versa ?
28/11/2011, 16h11
ZiGoM@r

Il s'agit d'un arbre, ils vont donc détruire leurs propres enfants, sauf si leurs pointeurs sont nuls. Je ne vois donc pas où est le problème.
28/11/2011, 19h39
3DArchi
ok. au temps pour moi.

Ceci dit il manque une politique de copie :
Code:

1 2 3 4 5 6 7 { Noeud<int> n(1); n.inserer(0); n.inserer(2); Noeud<int> n2 = n; }// boum ?