Difficultés avec les Listes chaînées de classe

**Tyra3l** · 13/01/2011, 17h41

Bonjour à tous,

Voilà j'ai un soucis avec les classes listes chaînées et je ne m'en sors pas...

Je commence à me familiariser avec les listes chaînées, chapitre que je trouve particulièrement difficile, toutefois avec des classes... je pattoge totalement...

Voilà je dois gérer un programme de gestion d'articles de magasins avec chaque article un prix (float) et un indicatif de solde (0 ou 1 de type bool) pour savoir si le produit est soldé ou non.

J'ai donc matérialisé ça par une classe Etiquette, mais après il me faut faire la somme des prix des différents produits inscrits dans la liste chaînée, j'ai créé un code, il compile pas de soucis, toutefois... il rentre une seule fois dans ma boucle alors qu'il devrait y rentrer 11 fois et me renvoi 0 comme prix

Pouvez-vous m'aider je vous prie ?

Je vous colle mon code afin que vous vous fassiez une idée plus claire :

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
 
 
#include <iostream>
 
using namespace std;
 
 
/** Modélisation de la classe étiquette **/
class Etiquette
{
    private:
            float prix_hors_reduc;
            bool is_solde;              // 0 pour non soldé, 1 pour soldé
 
    public:
            Etiquette(float phr = 0.0, bool is = 0)
            {
                prix_hors_reduc = phr;
                is_solde = is;
            }
 
            void saisie()
            {
                cout << "Entrez le prix du vêtement non-soldé : ";
                cin >> prix_hors_reduc;
                cout << endl;
                cout << "Le vêtement est-il soldé ? [1 => Oui / 0 => Non] ";
                cin >> is_solde;
            }
 
            void saisie(float prix, bool is)
            {
                prix_hors_reduc = prix;
                is_solde = is;
            }
 
            void affichage()
            {
                cout << prix_hors_reduc <<", ";
                if(is_solde == 1)
                    cout << "soldé" << endl;
                else if(is_solde == 0)
                    cout << "non soldé" << endl;
            }
 
            float get_prix()
            {
                return prix_hors_reduc;
            }
 
            char get_solde()
            {
                return is_solde;
            }
 
            void setPHR(float v)
            {
                prix_hors_reduc = v;
            }
 
            void setIS(bool c)
            {
                is_solde = c;
            }
};
 
 
/** Liste chainée d'étiquette **/
 
 
class MaillonE
{
    private :
        /** donnée membre du maillon*/
        Etiquette valeur;
 
        /** donnée membre l'adresse du maillon suivant*/
        MaillonE *suivant;
 
    public :
        /** Constructeur **/
        MaillonE()
        {}
 
        Etiquette getvaleur()
        {
            return valeur;
        }
 
        /** Retourne le prix de l'étiquette **/
        float getvaleurPHR()
        {
            float gp = valeur.get_prix();
            return gp;
        }
 
        /** Retourne le booléen si le produit est soldé ou non **/
        bool getvaleurIS()
        {
            bool gs = valeur.get_solde();
            return gs;
        }
 
        /** Modifie la valeur de l'étiquette **/
        void setvaleur(Etiquette v)
        {
            valeur = v;
        }
 
        bool hasSuivant()
        {
            return suivant != 0;
        }
 
        /** Retourne la valeur de l'adresse du maillon suivant **/
        MaillonE * getsuivant()
        {
            return suivant;
        }
 
        /** Modifie la valeur de l'adresse du maillon suivant **/
        void setsuivant(MaillonE * s)
        {
            suivant = s;
        }
};
 
 
class EnsembleE
{
    private :
        /** Donnée membre la liste de retraités **/
        MaillonE* liste;
 
    public :
 
        /** Constructeur **/
        EnsembleE()
        {
            liste = NULL;
        }
 
        /** Test de la liste vide **/
        int estVide()
        {
            return(liste == NULL);
        }
 
        /** Ajouter un retraite **/
        void ajout (Etiquette v)
        {
            MaillonE * e;
            e = new (MaillonE);
            (*e).setvaleur(v);
            (*e).setsuivant(liste);
            liste = e;
        }
 
        /** Premier element de la liste **/
        Etiquette premier()
        {
            return((*liste).getvaleur());
        }
 
        /** Creer une liste qui est la fin de la liste d'origine */
        EnsembleE fin ()
        {
            EnsembleE retour;
            retour.liste= (*liste).getsuivant();
            return (retour);
        }
 
        /** Afficher la liste */
        void afficher()
        {
            if (! estVide())
            {
                premier().affichage();
                cout << endl;
                cout << endl;
                fin().afficher();
            }
        }
 
 
        /** Fonction d'initialisation par valeurs par défaut **/
 
        void initialise(EnsembleE* m, Etiquette v)
        {
 
            v.saisie(12.04, 1);
            (*m).ajout(v);
 
            v.saisie(8.04, 1);
            (*m).ajout(v);
 
            v.saisie(5.04, 1);
            (*m).ajout(v);
 
            v.saisie(5.3, 0);
            (*m).ajout(v);
 
            v.saisie(20.3, 1);
            (*m).ajout(v);
 
            v.saisie(14.3, 1);
            (*m).ajout(v);
 
            v.saisie(11.3, 0);
            (*m).ajout(v);
 
            v.saisie(5.3, 0);
            (*m).ajout(v);
 
            v.saisie(26.3, 1);
            (*m).ajout(v);
 
            v.saisie(14.5, 1);
            (*m).ajout(v);
        }
 
        void sommeHReduc(EnsembleE* e)
        {
            MaillonE* m;
            m = new MaillonE;
 
            float i = 0;
            float phr = 0;
 
            while((*m).hasSuivant())
            {
                i = (*m).getvaleurPHR();
                cout << "i : " << i << endl;
                phr = phr + i;
                (*m).setsuivant(m);
            }
 
            cout << "La somme des prix hors réduction des produits est de : " << phr << endl;
        }
 
};
 
 
int main()
{
    EnsembleE* maListe = NULL;
    maListe = new EnsembleE;
    Etiquette v;
 
    maListe->initialise(maListe, v);
 
    v.saisie(18.2, 0);
    maListe->ajout(v);
 
    maListe->afficher();
 
    maListe->sommeHReduc(maListe);
 
}

En espérant que vous me sortiez de ce mauvais pas...

Merci d'avance !

**regis.portalez** · 13/01/2011, 17h49

Salut,

pourquoi n'utilises tu pas les list de la librairie standard?
http://www.cplusplus.com/reference/stl/list/

Ton booleen "solde" ne me paraît pas une bonne idée, à ta place je mettrai un pourcentage (float entre 0 et 1), ce qui te permet de solder à plusieurs valeurs (genre 50%, 20%...)
En plus tu fais souvent des conversions de types sur ce truc, il passe d'int à bool à char de temps en temps, ce qui n'est pas top.

Pour ton problème, as tu essayé de voir ce qu'il y avait dans ta liste avant de boucler dessus pour y faire des choses?
Du genre tu affiches sa taille à l'écran et tu vérifies qu'il y a le bon nombre d'étiquettes...

**Tyra3l** · 13/01/2011, 18h00

Bonjour,

Tout d'abord merci de ta réponse.

Pour ce qui est de la librairie standard je ne l'utilise pas car c'est une contrainte que j'ai de gérer ceci par des listes chaînées "a la mano".

Ensuite pour mon booléen, il ne s'agit pas d'indiquer le taux de solde, mais uniquement savoir s'il est ou non en solde.

Enfin comment puis-je voir s'il y a le bon nombre d'étiquettes ?

Toutefois lorsque j'affiche la liste, tous les éléments que j'ai entré grâce à la méthode initialise() apparaissent bien, sans exceptions...

Merci.

**regis.portalez** · 13/01/2011, 18h37

alors voici la correction

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


#include <iostream>

using namespace std;


/** Modélisation de la classe étiquette **/
class Etiquette
{
private:
	float prix_hors_reduc;
	bool is_solde;              // 0 pour non soldé, 1 pour soldé

public:
	Etiquette(float phr = 0.0, bool is = 0)
	{
		prix_hors_reduc = phr;
		is_solde = is;
	}

	void saisie()
	{
		cout << "Entrez le prix du vêtement non-solde : ";
		cin >> prix_hors_reduc;
		cout << endl;
		cout << "Le vetement est-il soldé ? [1 => Oui / 0 => Non] ";
		cin >> is_solde;
	}

	void saisie(float prix, bool is)
	{
		prix_hors_reduc = prix;
		is_solde = is;
	}

	void affichage()
	{
		cout << prix_hors_reduc <<", ";
		if(is_solde == 1)
			cout << "solde" << endl;
		else if(is_solde == 0)
			cout << "non solde" << endl;
	}

	float get_prix()
	{
		return prix_hors_reduc;
	}

	char get_solde()
	{
		return is_solde;
	}

	void setPHR(float v)
	{
		prix_hors_reduc = v;
	}

	void setIS(bool c)
	{
		is_solde = c;
	}
};


/** Liste chainée d'étiquette **/


class MaillonE
{
private :
	/** donnée membre du maillon*/
	Etiquette valeur;

	/** donnée membre l'adresse du maillon suivant*/
	MaillonE *suivant;

public :
	/** Constructeur **/
	MaillonE()
	{
		suivant = NULL ;
	}

	Etiquette getvaleur()
	{
		return valeur;
	}

	/** Retourne le prix de l'étiquette **/
	float getvaleurPHR()
	{
		return valeur.get_prix();
	}

	/** Retourne le booléen si le produit est soldé ou non **/
	bool getvaleurIS()
	{
		bool gs = valeur.get_solde() != 0 ? true : false ;
		return gs;
	}

	/** Modifie la valeur de l'étiquette **/
	void setvaleur(Etiquette v)
	{
		valeur = v;
	}

	bool hasSuivant()
	{
		return suivant != NULL ;
	}

	/** Retourne la valeur de l'adresse du maillon suivant **/
	MaillonE * getsuivant()
	{
		return suivant;
	}

	/** Modifie la valeur de l'adresse du maillon suivant **/
	void setsuivant(MaillonE * s)
	{
		suivant = s ;
	}
};


class EnsembleE
{
private :
	/** Donnée membre la liste de retraités **/
	MaillonE* liste;

public :

	/** Constructeur **/
	EnsembleE()
	{
AUTRE ERREUR ICIliste = NULL;
	}

	MaillonE* getliste ()
	{
		return liste ;
	}

	/** Test de la liste vide **/
	int estVide()
	{
		return(liste == NULL);
	}

	/** Ajouter un retraite **/
	void ajout (Etiquette v)
	{
		MaillonE * e;
		e = new (MaillonE);
		(*e).setvaleur(v);
		(*e).setsuivant(liste);
		liste = e;
	}

	/** Premier element de la liste **/
	Etiquette premier()
	{
		return((*liste).getvaleur());
	}

	/** Creer une liste qui est la fin de la liste d'origine */
	EnsembleE fin ()
	{
		EnsembleE retour;
		retour.liste= (*liste).getsuivant();
		return (retour);
	}

	/** Afficher la liste */
	void afficher()
	{
		if (! estVide())
		{
			premier().affichage();
			cout << endl;
			fin().afficher();
		}
	}


	/** Fonction d'initialisation par valeurs par défaut **/

	void initialise(EnsembleE* m, Etiquette v)
	{

		v.saisie(12.04f, 1);
		(*m).ajout(v);

		v.saisie(8.04f, 1);
		(*m).ajout(v);

		v.saisie(5.04f, 1);
		(*m).ajout(v);

		v.saisie(5.3f, 0);
		(*m).ajout(v);

		v.saisie(20.3f, 1);
		(*m).ajout(v);

		v.saisie(14.3f, 1);
		(*m).ajout(v);

		v.saisie(11.3f, 0);
		(*m).ajout(v);

		v.saisie(5.3f, 0);
		(*m).ajout(v);

		v.saisie(26.3f, 1);
		(*m).ajout(v);

		v.saisie(14.5f, 1);
		(*m).ajout(v);
	}

	void sommeHReduc(EnsembleE* e)
	{
		MaillonE* m = e->getliste() ;

		float i = 0.f ;
		float phr = 0.f ;

		while((*m).hasSuivant())
		{
			i = (*m).getvaleurPHR();
			cout << "i : " << i << endl;
			phr = phr + i;
	ERREUR ICI      m = m->getsuivant() ; // *m).setsuivant(m);
		}

		cout << "La somme des prix hors reduction des produits est de : " << phr << endl;
	}

};


int main()
{
	EnsembleE* maListe = NULL;
	maListe = new EnsembleE;
	Etiquette v;

	maListe->initialise(maListe, v);

	v.saisie(18.2f, 0);
	maListe->ajout(v);

	maListe->afficher();

	maListe->sommeHReduc(maListe);

}

En gros ton constructeur d'ensemble n'initialisait pas à NULL, d'où la boucle infinie à l'affichage (le premier élément avait toujours un suivant...)

Et ensuite l'appel à la méthode setsuivant ne faisait pas le saut de pointeur voulu pour afficher l'élément suivant.

J'ai aussi corrigé les warnings (c'est une manie

)

Bonne journée !

**Tyra3l** · 13/01/2011, 19h07

Oh merci infiniment !

Je vais enfin pouvoir avancé, merci encore pour cette correction que j'ai étudié et j'ai donc compris les erreurs que j'avais fait.

Ce n'est pas évident, je trouve tout de même ce chapitre particulièrement délicat et difficile.

Merci encore.

Bonne journée !

Difficultés avec les Listes chaînées de classe

Langage C++

Discussions similaires

Partager

Partager