Je ne sais pas trier mes lignes de texte :?

Bonjour tout le monde,

J'ai une méthode qui permet de trier :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
int CChaine::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	switch (TypeComparaison)
	{
	case ComparaisonPourUnicite:
		return strcmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriCroissantStrict:
		return strcmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriDecroissantStrict:
		return -strcmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriCroissantNonStrict:
		return stricmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriDecroissantNonStrict:
		return -stricmp(Chaine(),((const CChaine&)Autre).Chaine());
	}
	return 0;
}

case ComparaisonPourUnicite: s'est pour gérer l'unicité, s'est comme un filtre, les lignes ou les mots du fichier texte ne sont pas chargés ni affichés deux fois, ça, ça fonctionne.

Par contre, le tri ne fonctionne pas.

Code:

if(TypeComparaison == 1) return m_NomProduit.Comparer(m_NomProduit,Comparaison_TriCroissantNonStrict);

Je pense que la façon de trier est par rapport à ceci :

Code:

1
2
3
4
void CTabProduits::Trier()
{
	CTableauGenerique::Trier(1);
}

et j'ai aussi ceci :

l

Code:

1
2
3
4
ong CProduit::NombreClesDeTri() const
{
	return 1;
}

et bien si j'ai ces produits dans mon fichier txt :

Citation:

poulet 60
carotte 10
huile d'olive 70
tomate 20
poivron 40
oeuf 20
lavande 50
truffe 100
piment 80
sauge 90
carotte 1000
12
ail -10

J'obtiens ceci :

Citation:

oeuf 20
carotte 10
huile d'olive 70
tomate 20
poivron 40
poulet 60
lavande 50
truffe 100
piment 80
sauge 90

par contre ces trois articles-ci ne sont pas chargés car les ils n'ont pas passés les tests de validités (doublon, strlen(chaine) >0 et Prix >0 :

Citation:

carotte 1000
12
ail -10

Je me demande dans quel ordre s'est trié :?

Voici les classes concernées par le tri :

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
#include <BasicConsole.h>
#include "produits.h"
 
//////////////
// CProduit //
/////////////
 
CProduit::CProduit()
:m_PP(0)
{
}
 
CProduit::CProduit(const CProduit& Source)
:CGenerique(Source),m_NomProduit(Source.m_NomProduit),m_PP(Source.m_PP)
{
}
 
CProduit::CProduit(const char* UnNom, int UnPrix)
:m_PP(0) //on recopie la même chose que dans le constructeur spécifique
{	
	SetNomProduit(UnNom);
	SetPrixProduit(UnPrix);
}
 
CProduit::~CProduit()
{
}
 
bool CProduit::SetNomProduit(const char* UnNom)
{
	if((strlen(UnNom)<1)&&(UnNom==NULL))return false;
	return m_NomProduit.Chaine(UnNom);
}
 
bool CProduit::SetPrixProduit(int UnPrix)
{
	if(UnPrix<1)return false;
	m_PP = UnPrix;
	return true;
}
 
const char* CProduit::GetNomProduit() const
{
	return m_NomProduit.Chaine();
}
 
int CProduit::GetPrixProduit() const
{
	return m_PP;
}
 
CGenerique* CProduit::Cloner() const
{
	return new CProduit(*this);
}
 
bool CProduit::EstValide() const
{
	return(strlen(GetNomProduit())>1)&&(GetPrixProduit()>1);
}
 
bool CProduit::GereUnicite() const
{
	return true;
}
 
 
int CProduit::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	if(TypeComparaison == 0) return m_NomProduit.Comparer(((const CProduit&)Autre).m_NomProduit,Comparaison_TriCroissantNonStrict);
	if(TypeComparaison == 1) return m_NomProduit.Comparer(m_NomProduit,Comparaison_TriCroissantNonStrict);
 
}
 
long CProduit::NombreClesDeTri() const
{
	return 1;
}
 
//////////////////
// CTabProduits //
//////////////////
 
CTabProduits::CTabProduits()
:CTableauGenerique(CProduit())
{
}
 
CTabProduits::CTabProduits(const CTabProduits& Source)
:CTableauGenerique(Source)
{
}
 
CTabProduits::~CTabProduits()
{
}
 
CGenerique* CTabProduits::Cloner() const
{
	return new CTabProduits(*this);
}
 
CProduit& CTabProduits::Element(long Indice) const
{
	return (CProduit&)CTableauGenerique::Element(Indice);
}
 
long CTabProduits::Indice(const char* UnNom) const
{
	return CTableauGenerique::Indice(CProduit(UnNom,1));
}
 
bool CTabProduits::Ajouter(const CProduit& Modele)
{
	return CTableauGenerique::Ajouter(Modele);
}
 
/////////////////////////
// CTraitementProduits //
/////////////////////////
 
CTraitementProduits::CTraitementProduits()
{
}
 
CTraitementProduits::~CTraitementProduits()
{
}
 
bool CTraitementProduits::Charger(const char* NomFichier)
{
	CChargeurFichierTexte	Chargeur;
 
	if (!Chargeur.Charger(NomFichier,'\t',FctnTraiterLigne,this)) return false;
	m_Produits.Trier();
 
/*	// Affichage des deux tableaux*/
	for (long n=0; n < m_Produits.Nombre(); n++)
	{
		CProduit& P = m_Produits.Element(n);
		printf("%s \t\t  %ld\n",P.GetNomProduit(),P.GetPrixProduit());
	}
 
	return true;
}
 
bool CTraitementProduits::FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTraitementProduits*)Contexte)->TraiterLigne(Chargeur);
}
 
bool CTraitementProduits::TraiterLigne(const CChargeurFichierTexte& Chargeur)
{
	if(Chargeur.NombreChamps() == 2) m_Produits.Ajouter(CProduit(Chargeur.Champs(0),atol(Chargeur.Champs(1))));
	return true;
}
 
void CTabProduits::Trier()
{
	CTableauGenerique::Trier(1);
}

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
#include <BasicConsole.h>
#include "chaine.h"
 
 
////////////////////
// Classe CChaine //
////////////////////
 
CChaine::CChaine()
:m_Chaine(NULL)
{
}
 
CChaine::CChaine(const CChaine& Source)
:m_Chaine(NULL)
{
	Chaine(Source.m_Chaine);
}
 
CChaine::CChaine(const char* UneChaine)
:m_Chaine(NULL)
{
	Chaine(UneChaine);
}
 
CChaine::~CChaine()
{
	Vider();
}
 
bool CChaine::GereUnicite() const
{
	return true;
}
 
long CChaine::NombreClesDeTri() const
{
	return 4;
}
 
CGenerique* CChaine::Cloner() const
{
	return new CChaine(*this);
}
 
bool CChaine::EstValide() const
{
	return true;
}
 
int CChaine::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	switch (TypeComparaison)
	{
	case ComparaisonPourUnicite:
		return strcmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriCroissantStrict:
		return strcmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriDecroissantStrict:
		return -strcmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriCroissantNonStrict:
		return stricmp(Chaine(),((const CChaine&)Autre).Chaine());
	case Comparaison_TriDecroissantNonStrict:
		return -stricmp(Chaine(),((const CChaine&)Autre).Chaine());
	}
	return 0;
}
 
void CChaine::Vider()
{
	if (m_Chaine != NULL)
	{
		free(m_Chaine);
		m_Chaine = NULL;
	}
}
 
bool CChaine::Chaine(const char* UneChaine)
{
	if (UneChaine == NULL) return false;
	void* Nouveau = realloc(m_Chaine,(strlen(UneChaine)+1)*sizeof(char));
	if (Nouveau == NULL) return false;
	m_Chaine = (char*)Nouveau;
	strcpy(m_Chaine,UneChaine);
	return true;
}
 
bool CChaine::Concatener(const char* UneChaine)
{
	if (UneChaine == NULL) return false;
	long Taille = strlen(Chaine());
	void* Nouveau = realloc(m_Chaine,(Taille+strlen(UneChaine)+1)*sizeof(char));
	if (Nouveau == NULL) return false;
	m_Chaine = (char*)Nouveau;
	strcpy(m_Chaine+Taille,UneChaine);
	return true;
}
 
bool CChaine::Concatener(long NombreFois, char Caractere)
{
	if (NombreFois < 1) return false;
	long Taille = strlen(Chaine());
	void* Nouveau = realloc(m_Chaine,(Taille+NombreFois+1)*sizeof(char));
	if (Nouveau == NULL) return false;
	m_Chaine = (char*)Nouveau;
	while (NombreFois-- > 0) m_Chaine[Taille++] = Caractere;
	m_Chaine[Taille] = 0;
	return true;
}
 
const char* CChaine::Chaine() const
{
	return (m_Chaine != NULL) ? m_Chaine : "";
}
 
bool CChaine::EstNull() const
{
	return (m_Chaine == NULL);
}
 
bool CChaine::EstVide() const
{
	return (m_Chaine == NULL) || (m_Chaine[0] == 0);
}
 
 
////////////////////////////
// Classe CChaineComposee //
////////////////////////////
 
CChaineComposee::CChaineComposee()
:m_NbrChamps(0),m_Champs(NULL)
{
}
 
CChaineComposee::CChaineComposee(const CChaineComposee& Source)
:CChaine(Source),m_NbrChamps(0),m_Champs(NULL)
{
	if (Source.m_NbrChamps > 0)
	{
		m_Champs = (char**)malloc(Source.m_NbrChamps*sizeof(char*));
		if (m_Champs != NULL)
		{
			m_NbrChamps = Source.m_NbrChamps;
			for (long n=0; n < Source.m_NbrChamps; n++)
			{
				long PosRel = Source.m_Champs[n] - Source.m_Champs[0];
				m_Champs[n] = ((char*)Chaine()) + PosRel;
			}
		}
	}
}
 
CChaineComposee::CChaineComposee(const char* UneChaine, char UnSeparateur)
:CChaine(UneChaine),m_NbrChamps(0),m_Champs(NULL)
{
	Decomposer(UnSeparateur);
}
 
CChaineComposee::~CChaineComposee()
{
	if (m_Champs) free(m_Champs);
}
 
bool CChaineComposee::GereUnicite() const
{
	return false;
}
 
long CChaineComposee::NombreClesDeTri() const
{
	return 0;
}
 
CGenerique* CChaineComposee::Cloner() const
{
	return new CChaineComposee(*this);
}
 
int CChaineComposee::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	return 0;
}
 
long CChaineComposee::NombreChamps() const
{
	return m_NbrChamps;
}
 
const char* CChaineComposee::Champs(long Indice) const
{
	return ( (Indice >= 0) && (Indice < m_NbrChamps) ) ? m_Champs[Indice] : "";
}
 
bool CChaineComposee::Definir(const char* UneChaine, char UnSeparateur)
{
	if (!Chaine(UneChaine)) return false;
	return Decomposer(UnSeparateur);
}
 
bool CChaineComposee::Decomposer(char UnSeparateur)
{
	m_NbrChamps = 0;
	char* Texte = (char*)Chaine();
	if (Texte == NULL) return false;
	void* Nouveau = realloc(m_Champs,1*sizeof(char*));
	if (Nouveau == NULL)
	{
		if (m_Champs)
		{
			free(m_Champs);
			m_Champs = NULL;
		}
		return false;
	}
	m_Champs = (char**)Nouveau;
	m_Champs[m_NbrChamps] = Texte;
	m_NbrChamps++;
	while (true)
	{
		char* Delimiteur = strchr(Texte,UnSeparateur);
		if (Delimiteur == NULL) return true;
		*Delimiteur = 0;
		Texte = Delimiteur + 1;
		void* Nouveau = realloc(m_Champs,(m_NbrChamps+1)*sizeof(char*));
		if (Nouveau == NULL) return false;
		m_Champs = (char**)Nouveau;
		m_Champs[m_NbrChamps] = Texte;
		m_NbrChamps++;
	}
}
 
 
//////////////////////////////////
// Classe CChargeurFichierTexte //
//////////////////////////////////
 
CChargeurFichierTexte::CChargeurFichierTexte()
{
}
 
CChargeurFichierTexte::CChargeurFichierTexte(const CChargeurFichierTexte& Source)
:CChaineComposee(Source)
{
}
 
CChargeurFichierTexte::~CChargeurFichierTexte()
{
}
 
CGenerique* CChargeurFichierTexte::Cloner() const
{
	return (CGenerique*)((void*)new CChargeurFichierTexte(*this));
}
 
bool CChargeurFichierTexte::Charger(const char* NomFichier, char UnSeparateur, bool (* FctnTraiterLigne)(const CChargeurFichierTexte&, void*), void* Contexte)
{
	const long		TailleLigne = 500;
	char			Ligne[TailleLigne+1];
	FILE*			Fichier;
 
	if ( (NomFichier == NULL) || (*NomFichier == 0) ) return false;
	Fichier = fopen(NomFichier,"rt");
	if (Fichier == NULL) return false;
	while (fgets(Ligne,TailleLigne,Fichier) != NULL)
	{
		long i = strlen(Ligne);
		if ( (i > 0) && (Ligne[i-1] == '\n') ) Ligne[i-1] = 0;
		if (Definir(Ligne,'\t'))
		{
			if (!FctnTraiterLigne(*this,Contexte))
			{
				fclose(Fichier);
				return false;
			}
		}
	}
	fclose(Fichier);
	return true;
}

et voici ma méthode de tri :

Code:

1
2
3
4
5
6
7
8
9
void CTableauGenerique::Trier(long TypeComparaison)
{
	if ( (m_Nombre >= 2) && (TypeComparaison >= 1) && (TypeComparaison <= m_Poubelle->NombreClesDeTri()) )
	{
		m_TypeComparaison = TypeComparaison;
		qsort(m_Tableau,m_Nombre,sizeof(CGenerique*),Comparer);
		m_TypeComparaison = -1;
	}
}

et la méthode comparer :

Code:

1
2
3
4
5
6
/*static*/int CTableauGenerique::Comparer(const void* p1, const void* p2)
{
	const CGenerique* o1 = *((const CGenerique**)p1);
	const CGenerique* o2 = *((const CGenerique**)p2);
	return o1->Comparer(*o2,o2->Conteneur()->m_TypeComparaison);
}

Sauriez-vous m'aider svp ?

Je vous en remercie d'avance.

beegees

Salut,

Est-ce que le prof vous a donné un exemple de tri qui marchait? (8-))

Sinon, pour le problème, à mon avis tu ferais mieux de faire un zip avec toutes tes sources et le fichier txt, enfin essaie de chercher un peu quand même ;)

Citation:

Envoyé par coyotte507

Salut,

Est-ce que le prof vous a donné un exemple de tri qui marchait? (8-))

Sinon, pour le problème, à mon avis tu ferais mieux de faire un zip avec toutes tes sources et le fichier txt, enfin essaie de chercher un peu quand même ;)

Salut Coyotte,

Je te promets que je cherche depuis des heures :?.

J'ai tout tenté !

Il y'a un classement, mais je ne sais pas par quoi car quand je n'applique pas de tri, il m'affiche les données telles qu'elles sont dans le txt, ce n'est pas la même chose que ce que j'obtiens.

Voici un exercice où le tri fonctionne (chien.zip)

et voici mon exercice où ça ne fonctionne pas (produits.zip)

Encore une fois, j'ai cherché depuis ce matin (car ce matin j'avais un autre gros problème que j'ai résolu par moi-même).

Merci d'avance.

beegees

Salut,
Code:

1 2 if(TypeComparaison == 0) return m_NomProduit.Comparer(((const CProduit&)Autre).m_NomProduit,Comparaison_TriCroissantNonStrict); if(TypeComparaison == 1) return m_NomProduit.Comparer(((const CProduit&)Autre).m_NomProduit,Comparaison_TriCroissantNonStrict);
Je ne sais pas pourquoi, mais en cours d'exécution c'était d'abord 0 puis 1 que valait TypeComparaison.

Dans ta fonction Comparer, tu faisais:
Code:

1 2 if(TypeComparaison == 0) return m_NomProduit.Comparer(((const CProduit&)Autre).m_NomProduit,Comparaison_TriCroissantNonStrict); if(TypeComparaison == 1) return m_NomProduit.Comparer(m_NomProduit,Comparaison_TriCroissantNonStrict);
Donc quand TypeComparaison valait 1, tu comparais m_NomProduit à lui-même.

Autre chose: pour le main, utilise:
Code:

1 2 3 4 5 6 int main() { ... return 0; }
Et non pas le void main().

Bon dimanche!

Salut Coyotte,

Un tout grand merci d'avoir pris du temps pour répondre à ma question et surtout pour avoir pris la peine de compiler mon code et de le tester, surtout par un beau soleil comme on a aujourd'hui.

Citation:

Je ne sais pas pourquoi, mais en cours d'exécution c'était d'abord 0 puis 1 que valait TypeComparaison.

Voici ce qui va peut être répondre à ta question (ça s'applique à un autre exercice mais s'est la même optique) :

Citation:

Dans faux frères la clé d'unicité s'est le "Mot", donc il y'a une clé d'unicité mais "Gère Unicité" renverra VRAI et "Comparer" quand type comparaison vaut 0 fera sa comparaison sur le "Mot" et quand on utilisera "Trier" en interne il va vérifier combien il y'a de clé de tri, ça sera 1 donc je lui passerai la valeur 1, il dira OK le paramètre est bon et il utilisera qsort en utilisant "Comparer" mais en passant cette fois-ci comme type de comparaison non pas 0 mais 1 et donc quand s'est 1 je sais que moi je devrais comparer les éléments sur base de leur "Code".

Alors, je t'avoue que j'avais pas compris tout de suite que t'avais résolu le problème, toi, prépares-toi à une très belle carrière car tu es très bon :king:

Incroyable, maintenant que j'ai lu attentivement ton code et après l'avoir comparé avec le mien, je me dis que s'était tout bête mais je ne pense pas que j'aurais trouvé.

Sincèrement, un tout grand merci, tu es vraiment un des meilleurs sur ce forum, je n'ai pas à le cacher.

Respect :ave: :ave: :ave:

beegees

Salut,

Citation:

Envoyé par beegees

toi, prépares-toi à une très belle carrière car tu es très bon :king:

ben je crois alors que je vais plus me concentrer sur mes études et passer moins de temps sur ce forum :mouarf:

Et puis il faut relativiser, j'ai été assez actif récemment mais je suis loin d'être celui qui a le plus d'expérience sur ce forum :P

Sur ce,

:coucou: