Discussion :

[beegees]

Bonjour tout le monde,

J'essaie à partir de code existant de faire un exercice.

Mon programme tourne fou, j'ai mis des points d'arrêt et alors qui'l ne doit lire qu'une seule ligne d'un fichier txt, après plus de 150 clic sur F5, ça continue.

Voici la ligne sur lequel le programme tourne fou :

Code :

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

TabClassifications.Ajouter(Classifications);

L'appel ci-dessus va sur cette méthode :

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
bool CTableauGenerique::Ajouter(const CGenerique& ModeleAAjouter, bool RetourEnCasDeDoublon)
{
	if (!ModeleAAjouter.EstValide()) return false;
	if ( (m_Poubelle->GereUnicite()) && (Indice(ModeleAAjouter) >= 0) ) return RetourEnCasDeDoublon;
	void* Nouveau = realloc(m_Tableau,(m_Nombre+1)*sizeof(CGenerique*));
	if (Nouveau == NULL) return false;
	m_Tableau = (CGenerique**)Nouveau;
	CGenerique* AAjouter = ModeleAAjouter.Cloner();
	if (!AAjouter->EstValide())
	{
		delete AAjouter;
		return false;
	}
	m_Tableau[m_Nombre] = AAjouter;
	m_Tableau[m_Nombre]->DefinirConteneur(this);
	m_Nombre++;
	return true;
}

donc il n'arrive jamais ici :

for (n=0; n < TabClassifications.Nombre(); n++)


Voici le code de mon main :

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
#include <BasicConsole.h>
#include "vehicule.h"
 
void main()
{
	long	n;
 
	CTableauGenerique	TabVehicules((const CGenerique&)CTabVehicules());
	for (n=1; true; n++)
	{
		CTabVehicules	Vehicules;
		char			NomFichier[26];
		sprintf(NomFichier,"vehicules.%ld.txt",n);
		if (!Vehicules.Charger(NomFichier)) break;
		Vehicules.Trier();
		TabVehicules.Ajouter(Vehicules);
	}
	for (n=0; n < TabVehicules.Nombre(); n++)
	{
		printf("\n\nTableau des véhicules de \"vehicules.%ld.txt\"\n",n+1);
		((CTabVehicules&)TabVehicules.Element(n)).Afficher();
	}
}
 
/*
void main()
{
	CTabVehicules	Vehicules;
 
	if (Vehicules.Charger("vehicules.txt"))
	{
		Vehicules.Trier();
		printf("Tous les véhicules...\n");
		Vehicules.Afficher();
		printf("\nUniquement les voitures...\n");
		Vehicules.Afficher("Voiture");
		printf("\nUniquement les camions...\n");
		Vehicules.Afficher("Camion");
		printf("\nUniquement les bus...\n");
		Vehicules.Afficher("Bus");
	}
}
*/

Voici aussi mon fichier cpp :

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
#include <BasicConsole.h>
#include <search.h>
#include "chiens.h"
 
//il faut donc encore créer les classes origines et utilisations
 
/////////////////
//Class CChiens//
////////////////
 
CChiens::CChiens()
{
}
 
CChiens::CChiens(const CChiens& Source) 
:CGenerique(Source),m_Nom(Source.m_Nom)
{
}
 
CChiens::CChiens(const char* UnNom)//OK
{
	Nom(UnNom);
}
 
 
CTabClassifications::~CTabClassifications()
{
}
 
bool CChiens::Nom(const char* UnNom) //ok
{
	if ( (UnNom == NULL) || (strlen(UnNom) < 2) ) return false;
	return m_Nom.Chaine(UnNom);
 
}
 
void CChiens::Afficher()const
{
	printf("- Classifications : %s\n",Nom());
}
 
CTabClassifications::CTabClassifications(const CTabClassifications& Source)
:CTableauGenerique(Source)
{
}
 
 
void CTabClassifications::Afficher(const char* FiltreSurType) const
{	long ordre = 0;
	for (long n=0; n < 10; n++)
	{
		if ( (FiltreSurType == NULL) || (strcmp(Element(n).Type(),FiltreSurType) == 0) )
		{
			ordre++;
			printf("%s n°%ld :\n",Element(n).Type(),ordre);
			Element(n).Afficher();
		}
	}
 
}
 
const char* CChiens::Type() const
{
	return null;
}
 
int CChiens::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	return 0;
}
 
bool CChiens::EstValide() const
{
	return true;
}
 
CGenerique* CChiens::Cloner() const
{
	return new CChiens(*this);
}
 
long CChiens::NombreClesDeTri() const
{
	return 1;
}
 
bool CChiens::GereUnicite() const
{
	return true;
}
 
CChiens::~CChiens()
{
 
}
 
const char* CChiens::Nom() const
{
	return m_Nom.Chaine();
}
 
 
CChiens& CTabClassifications::Element(long UnIndice) const
{
	return (CChiens&)CTableauGenerique::Element(UnIndice);
}
///////////////////////////////
//Class CTabClassifications////
///////////////////////////////
 
CTabClassifications::CTabClassifications()
:CTableauGenerique(CChiens("POUBELLE"))
{
}
 
long CTabClassifications::Indice(const char* UnNom) const
{
	//ici je ne passe que le nom et pas le compteur, on travaille ici avec le constructeur spécifique
	//de la classe CChiens ! donc je ne passe qu'un paramètre contrairement aux véhicules
	//donc je vérifie le nom dans le tableau, si il existe déjà j'incrémente le compteur
	//autrement je l'ajoute et j'incrémente le compteur.
 
 
	//dans les tableaux il ne faut pas remettre les membres !!!!
	return CTableauGenerique::Indice(CChiens(UnNom));
 
}
 
bool CTabClassifications::Ajouter(const CChiens& Modele)
{
	return CTableauGenerique::Ajouter(Modele);
}
 
void CTabClassifications::Trier()
{
	CTableauGenerique::Trier(ComparaisonPourTri);
}
 
bool CTabClassifications::Charger(const char* NomFichier)
{
	CChargeurFichierTexte	Chargeur;
 
	return Chargeur.Charger(NomFichier,'\t',CTabClassifications::FctnTraiterLigne,this);
}
 
/*static*/ bool CTabClassifications::FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTabClassifications*)Contexte)->TraiterLigne(Chargeur);
}
 
 
bool CTabClassifications::TraiterLigne(const CChargeurFichierTexte& Chargeur)
 
//le chargeur ouvre le fichier, lit ligne par ligne et éclate la ligne, il n'y a donc plus rien à faire
{
	if (Chargeur.NombreChamps() == 4)
	{
		Ajouter(CChiens(Chargeur.Champs(1)));
	}
	return true;
}

Si vous avez besoin d'autre info n'héistez pas à me le dire.

Un tout grand merci d'avance pour votre aide.

beegees

[droggo]

Fao,

La boucle

Code :

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

	for (n=1; true; n++)

est infinie, puisque tu mets comme condition d'arrêt true, qui, étant une constante, ne changera pas.

[beegees]

Fao,

La boucle

Code :

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

	for (n=1; true; n++)

est infinie, puisque tu mets comme condition d'arrêt true, qui, étant une constante, ne changera pas.

Salut,

Merci pour ta réponse.

Ce qui est étrange s'est que je me base sur un autre exercice, cet autre exercice utilise cette boucle infinie qui se termine :

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
	CTableauGenerique	TabVehicules((const CGenerique&)CTabVehicules());
	for (n=1; true; n++)
	{
		CTabVehicules	Vehicules;
		char			NomFichier[26];
		sprintf(NomFichier,"vehicules.%ld.txt",n);
		if (!Vehicules.Charger(NomFichier)) break;
		Vehicules.Trier();
		TabVehicules.Ajouter(Vehicules);
	}
	for (n=0; n < TabVehicules.Nombre(); n++)
	{
		printf("\n\nTableau des véhicules de \"vehicules.%ld.txt\"\n",n+1);
		((CTabVehicules&)TabVehicules.Element(n)).Afficher();
	}
}

Qu'en penses-tu ?

Merci encore.

beegees

[Le Farfadet Spatial]

Salut à tous !

Ce qui est étrange s'est que je me base sur un autre exercice, cet autre exercice utilise cette boucle infinie qui se termine :

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
	CTableauGenerique	TabVehicules((const CGenerique&)CTabVehicules());
	for (n=1; true; n++)
	{
		CTabVehicules	Vehicules;
		char			NomFichier[26];
		sprintf(NomFichier,"vehicules.%ld.txt",n);
		if (!Vehicules.Charger(NomFichier)) break;
		Vehicules.Trier();
		TabVehicules.Ajouter(Vehicules);
	}
	for (n=0; n < TabVehicules.Nombre(); n++)
	{
		printf("\n\nTableau des véhicules de \"vehicules.%ld.txt\"\n",n+1);
		((CTabVehicules&)TabVehicules.Element(n)).Afficher();
	}
}

Qu'en penses-tu ?

J'en pense que l'instruction break met fin à la boucle, de sorte que cette ligne :

Code :

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

if (!Vehicules.Charger(NomFichier)) break;

est là pour mettre fin à la boucle. Cela dit, je trouve cet exemple pas terrible, je te conseille de ne pas trop le prendre comme exemple.

À bientôt.

Le Farfadet Spatial

[beegees]

Salut Le Farfadet Spatial,

OK le problème doit venir de là car il arrive toujours à charger le fichier, s'est pas normal quand même ?

Merci pour ton aide.

beegees

[coyotte507]

Salut,

il faut voir le code de ta fonction Vehicule::chargerFichier

[beegees]

Salut,

il faut voir le code de ta fonction Vehicule::chargerFichier

Salut,

Heureux d'avoir de tes nouvelles.

Je pense que s'est ce que que tu demandes :

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
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;
}

En fait dans l'exercice avec les véhicules, il y'a un fichier1, un fichier 2 et un Fichier 3 qui se charge, ils existent, les fichiers txt existent donc s'est OK, quand on arrive à Fichier 4, il n'existe pas donc le break arrête la boucle infinie.

Je n'ai qu'un seul fichier dans l'exercice avec les chiens mais là il ne s'arrête pas.

Si je mets ceci :

Code :

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

1
2
 
for (n=1; n<2; n++)

Il sort de la boucle mais il ne lit pas mon fichier txt.

Merci à vous tous !

beegees

[coyotte507]

Salut,

heureux de te revoir aussi!

La fonction qui est appelée ici, pardon, c'est CTabVehicule::Charger.

Peux-tu la montrer?

[beegees]

Salut,

heureux de te revoir aussi!

La fonction qui est appelée ici, pardon, c'est CTabVehicule::Charger.

Peux-tu la montrer?

Salut Coyotte,

Je désespère car s'est vraiment très compliqué.

Je te laisse le code demandé :

Code :

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

1
2
3
4
5
6
bool CTabVehicules::Charger(const char* NomFichier)
{
	CChargeurFichierTexte	Chargeur;
 
	return Chargeur.Charger(NomFichier,'\t',CTabVehicules::FctnTraiterLigne,this);
}

Voici l'entierté de Vehicule.cpp :

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
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
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
#include <BasicConsole.h>
#include <search.h>
#include "vehicule.h"
 
 
/////////////////////
// class CVehicule //
/////////////////////
 
CVehicule::CVehicule()
:m_NombrePlaces(0)
{
}
 
CVehicule::CVehicule(const CVehicule& Source)
:CGenerique(Source),m_Immatriculation(Source.m_Immatriculation),m_NombrePlaces(Source.m_NombrePlaces)
{
}
 
CVehicule::CVehicule(const char* UneImmatriculation, short UnNombreDePlaces)
:m_NombrePlaces(0)
{
	Immatriculation(UneImmatriculation);
	NombrePlaces(UnNombreDePlaces);
}
 
CVehicule::~CVehicule()
{
}
 
bool CVehicule::GereUnicite() const
{
	return true;
}
 
long CVehicule::NombreClesDeTri() const
{
	return 1;
}
 
CGenerique* CVehicule::Cloner() const
{
	return new CVehicule(*this);
}
 
bool CVehicule::EstValide() const
{
	return (strlen(Immatriculation()) >= 5) && (NombrePlaces() >= 1);
}
 
int CVehicule::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	return stricmp(Immatriculation(),((const CVehicule&)Autre).Immatriculation());
}
 
const char* CVehicule::Type() const
{
	return "Véhicule";
}
 
const char* CVehicule::Immatriculation() const
{
	return m_Immatriculation.Chaine();
}
 
short CVehicule::NombrePlaces() const
{
	return m_NombrePlaces;
}
 
void CVehicule::Afficher() const
{
	printf("- immatriculation : %s\n- nombre de places : %d\n",Immatriculation(),NombrePlaces());
}
 
bool CVehicule::Immatriculation(const char* UneImmatriculation)
{
	if ( (UneImmatriculation == NULL) || (strlen(UneImmatriculation) < 5) ) return false;
	return m_Immatriculation.Chaine(UneImmatriculation);
}
 
bool CVehicule::NombrePlaces(short UnNombreDePlaces)
{
	if (UnNombreDePlaces < 1) return false;
	m_NombrePlaces = UnNombreDePlaces;
	return true;
}
 
 
////////////////////
// class CVoiture //
////////////////////
 
CVoiture::CVoiture()
:m_VolumeMarchandise(0.0)
{
}
 
CVoiture::CVoiture(const CVoiture& Source)
:CVehicule(Source),m_VolumeMarchandise(Source.m_VolumeMarchandise)
{
}
 
CVoiture::CVoiture(const char* UneImmatriculation, short UnNombreDePlaces, double UnVolumeDeMarchandise)
:CVehicule(UneImmatriculation,UnNombreDePlaces),m_VolumeMarchandise(0.0)
{
	VolumeMarchandise(UnVolumeDeMarchandise);
}
 
CVoiture::~CVoiture()
{
}
 
CGenerique* CVoiture::Cloner() const
{
	return new CVoiture(*this);
}
 
bool CVoiture::EstValide() const
{
	return (CVehicule::EstValide()) && (VolumeMarchandise() > 0.0);
}
 
const char* CVoiture::Type() const
{
	return "Voiture";
}
 
double CVoiture::VolumeMarchandise() const
{
	return m_VolumeMarchandise;
}
 
void CVoiture::Afficher() const
{
	CVehicule::Afficher();
	printf("- volume de marchandise : %lf m³\n",VolumeMarchandise());
}
 
bool CVoiture::VolumeMarchandise(double UnVolumeDeMarchandise)
{
	if (UnVolumeDeMarchandise <= 0.0) return false;
	m_VolumeMarchandise = UnVolumeDeMarchandise;
	return true;
}
 
 
///////////////////
// class CCamion //
///////////////////
 
CCamion::CCamion()
:m_VolumeMarchandise(0.0),m_PoidsMarchandise(0.0)
{
}
 
CCamion::CCamion(const CCamion& Source)
:CVehicule(Source),m_VolumeMarchandise(Source.m_VolumeMarchandise),m_PoidsMarchandise(Source.m_PoidsMarchandise)
{
}
 
CCamion::CCamion(const char* UneImmatriculation, short UnNombreDePlaces, double UnVolumeDeMarchandise, double UnPoidsDeMarchandise)
:CVehicule(UneImmatriculation,UnNombreDePlaces),m_VolumeMarchandise(0.0),m_PoidsMarchandise(0.0)
{
	VolumeMarchandise(UnVolumeDeMarchandise);
	PoidsMarchandise(UnPoidsDeMarchandise);
}
 
CCamion::~CCamion()
{
}
 
CGenerique* CCamion::Cloner() const
{
	return new CCamion(*this);
}
 
bool CCamion::EstValide() const
{
	return (CVehicule::EstValide()) && (VolumeMarchandise() > 0.0) && (PoidsMarchandise() > 0.0);
}
 
const char* CCamion::Type() const
{
	return "Camion";
}
 
double CCamion::VolumeMarchandise() const
{
	return m_VolumeMarchandise;
}
 
double CCamion::PoidsMarchandise() const
{
	return m_PoidsMarchandise;
}
 
void CCamion::Afficher() const
{
	CVehicule::Afficher();
	printf("- volume de marchandise : %lf m³\n- poids de marchandise : %lf tonne\n",VolumeMarchandise(),PoidsMarchandise());
}
 
bool CCamion::VolumeMarchandise(double UnVolumeDeMarchandise)
{
	if (UnVolumeDeMarchandise <= 0.0) return false;
	m_VolumeMarchandise = UnVolumeDeMarchandise;
	return true;
}
 
bool CCamion::PoidsMarchandise(double UnPoidsDeMarchandise)
{
	if (UnPoidsDeMarchandise <= 0.0) return false;
	m_PoidsMarchandise = UnPoidsDeMarchandise;
	return true;
}
 
 
////////////////
// class CBus //
////////////////
 
CBus::CBus()
:m_NombreRangs(0)
{
}
 
CBus::CBus(const CBus& Source)
:CVehicule(Source),m_NombreRangs(Source.m_NombreRangs)
{
}
 
CBus::CBus(const char* UneImmatriculation, short UnNombreDePlaces, short UnNombreDeRangs)
:CVehicule(UneImmatriculation,UnNombreDePlaces),m_NombreRangs(0)
{
	NombreRangs(UnNombreDeRangs);
}
 
CBus::~CBus()
{
}
 
CGenerique* CBus::Cloner() const
{
	return new CBus(*this);
}
 
bool CBus::EstValide() const
{
	return (CVehicule::EstValide()) && (NombreRangs() > 0);
}
 
const char* CBus::Type() const
{
	return "Bus";
}
 
short CBus::NombreRangs() const
{
	return m_NombreRangs;
}
 
void CBus::Afficher() const
{
	CVehicule::Afficher();
	printf("- nombre de rangs : %d\n",NombreRangs());
}
 
bool CBus::NombreRangs(short UnNombreDeRangs)
{
	if (UnNombreDeRangs <= 0) return false;
	m_NombreRangs = UnNombreDeRangs;
	return true;
}
 
 
/////////////////////////
// class CTabVehicules //
/////////////////////////
 
CTabVehicules::CTabVehicules()
:CTableauGenerique(CVehicule("POUBELLE",1))
{
}
 
CTabVehicules::CTabVehicules(const CTabVehicules& Source)
:CTableauGenerique(Source)
{
}
 
CTabVehicules::~CTabVehicules()
{
}
 
CVehicule& CTabVehicules::Element(long UnIndice) const
{
	return (CVehicule&)CTableauGenerique::Element(UnIndice);
}
 
long CTabVehicules::Indice(const char* UneImmatriculation) const
{
	return CTableauGenerique::Indice(CVehicule(UneImmatriculation,1));
}
 
bool CTabVehicules::Ajouter(const CVehicule& Modele)
{
	return CTableauGenerique::Ajouter(Modele);
}
 
void CTabVehicules::Trier()
{
	CTableauGenerique::Trier(ComparaisonPourTri);
}
 
void CTabVehicules::Afficher(const char* FiltreSurType) const
{
	long ordre = 0;
	for (long n=0; n < Nombre(); n++)
	{
		if ( (FiltreSurType == NULL) || (strcmp(Element(n).Type(),FiltreSurType) == 0) )
		{
			ordre++;
			printf("%s n°%ld :\n",Element(n).Type(),ordre);
			Element(n).Afficher();
		}
	}
}
 
bool CTabVehicules::Charger(const char* NomFichier)
{
	CChargeurFichierTexte	Chargeur;
 
	return Chargeur.Charger(NomFichier,'\t',CTabVehicules::FctnTraiterLigne,this);
}
 
/*static*/ bool CTabVehicules::FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTabVehicules*)Contexte)->TraiterLigne(Chargeur);
}
 
bool CTabVehicules::TraiterLigne(const CChargeurFichierTexte& Chargeur)
{
	if (strlen(Chargeur.Champs(0)) == 1) switch(Chargeur.Champs(0)[0])
	{
		case 'E':
			if (Chargeur.NombreChamps() == 3) Ajouter(CVehicule(Chargeur.Champs(1),(short)atol(Chargeur.Champs(2))));
			break;
		case 'V':
			if (Chargeur.NombreChamps() == 4) Ajouter(CVoiture(Chargeur.Champs(1),(short)atol(Chargeur.Champs(2)),atof(Chargeur.Champs(3))));
			break;
		case 'C':
			if (Chargeur.NombreChamps() == 5) Ajouter(CCamion(Chargeur.Champs(1),(short)atol(Chargeur.Champs(2)),atof(Chargeur.Champs(3)),atof(Chargeur.Champs(4))));
			break;
		case 'B':
			if (Chargeur.NombreChamps() == 4) Ajouter(CBus(Chargeur.Champs(1),(short)atol(Chargeur.Champs(2)),(short)atol(Chargeur.Champs(3))));
			break;
	}
	return true;
}

et aussi Chaine.cpp

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
#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;
}
 
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 aussi la classe générique.cpp

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
#include <BasicConsole.h>
#include <search.h>
#include "generique.h"
 
 
///////////////////////
// Classe CGenerique //
///////////////////////
 
CGenerique::CGenerique()
:m_Conteneur(NULL)
{
}
 
CGenerique::CGenerique(const CGenerique& Source)
:m_Conteneur(NULL)
{
}
 
CGenerique::~CGenerique()
{
}
 
bool CGenerique::GereUnicite() const
{
	return false;
}
 
long CGenerique::NombreClesDeTri() const
{
	return 0;
}
 
CGenerique* CGenerique::Cloner() const
{
	return new CGenerique(*this);
}
 
bool CGenerique::EstValide() const
{
	return true;
}
 
int CGenerique::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	return 0;
}
 
CTableauGenerique* CGenerique::Conteneur() const
{
	return m_Conteneur;
}
 
void CGenerique::DefinirConteneur(CTableauGenerique* Tableau)
{
	m_Conteneur = Tableau;
}
 
 
//////////////////////////////
// Classe CTableauGenerique //
//////////////////////////////
 
CTableauGenerique::CTableauGenerique(const CGenerique& ModelePoubelle)
:m_Poubelle(NULL),m_Nombre(0),m_Tableau(NULL),m_TypeComparaison(-1)
{
	m_Poubelle = ModelePoubelle.Cloner();
	m_Poubelle->DefinirConteneur(this);
}
 
CTableauGenerique::CTableauGenerique(const CTableauGenerique& Source)
:m_Poubelle(NULL),m_Nombre(0),m_Tableau(NULL),m_TypeComparaison(-1)
{
	m_Poubelle = Source.m_Poubelle->Cloner();
	for (long n=0; n < Source.m_Nombre; n++) Ajouter(Source.Element(n));
}
 
CTableauGenerique::~CTableauGenerique()
{
	Vider();
	delete m_Poubelle;
}
 
CGenerique* CTableauGenerique::Cloner() const
{
	return new CTableauGenerique(*this);
}
 
long CTableauGenerique::Nombre() const
{
	return m_Nombre;
}
 
CGenerique& CTableauGenerique::Element(long Indice) const
{
	return ((Indice >= 0) && (Indice < m_Nombre)) ? *(m_Tableau[Indice]) : *m_Poubelle;
}
 
long CTableauGenerique::Indice(const CGenerique& ModeleRecherche) const
{
	if ( (m_Nombre == 0) || (!m_Poubelle->GereUnicite()) || (!ModeleRecherche.EstValide()) ) return -1;
	const CGenerique* Recherche = &ModeleRecherche;
	unsigned int n = m_Nombre;
	((CTableauGenerique*)this)->m_TypeComparaison = ComparaisonPourUnicite;
	CGenerique** Trouve = (CGenerique**)_lfind(&Recherche,m_Tableau,&n,sizeof(CGenerique*),Comparer);
	((CTableauGenerique*)this)->m_TypeComparaison = -1;
	return (Trouve != NULL) ? Trouve - m_Tableau : -1;
}
 
void CTableauGenerique::Vider()
{
	if (m_Tableau != NULL)
	{
		for (long n=0; n < m_Nombre; n++) delete m_Tableau[n];
		free(m_Tableau);
		m_Tableau = NULL;
		m_Nombre = 0;
	}
}
 
bool CTableauGenerique::Ajouter(const CGenerique& ModeleAAjouter, bool RetourEnCasDeDoublon)
{
	if (!ModeleAAjouter.EstValide()) return false;
	if ( (m_Poubelle->GereUnicite()) && (Indice(ModeleAAjouter) >= 0) ) return RetourEnCasDeDoublon;
	void* Nouveau = realloc(m_Tableau,(m_Nombre+1)*sizeof(CGenerique*));
	if (Nouveau == NULL) return false;
	m_Tableau = (CGenerique**)Nouveau;
	CGenerique* AAjouter = ModeleAAjouter.Cloner();
	if (!AAjouter->EstValide())
	{
		delete AAjouter;
		return false;
	}
	m_Tableau[m_Nombre] = AAjouter;
	m_Tableau[m_Nombre]->DefinirConteneur(this);
	m_Nombre++;
	return true;
}
 
bool CTableauGenerique::Supprimer(long Indice)
{
	if ( (Indice < 0) || (Indice >= m_Nombre) ) return false;
	delete m_Tableau[Indice];
	if (Indice < (m_Nombre-1)) memmove(m_Tableau+Indice,m_Tableau+(Indice+1),(m_Nombre-1-Indice)*sizeof(CGenerique*));
	realloc(m_Tableau,(m_Nombre-1)*sizeof(CGenerique*));
	m_Nombre--;
	return true;
}
 
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;
	}
}
 
/*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);
}

J'espère que tu as tout.

Merci sincèrement pour le temps que tu me consacres.

beegees

[coyotte507]

Salut,

c'est bizarre:

Code :

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

if (Fichier == NULL) return false;

Et donc on devrait sortir...

Avec un code si compliqué, une seule solution: le débugger.

Peux tu zipper ton projet (avec tous les fichiers) et l'uploader?

[beegees]

Salut,

c'est bizarre:

Code :

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

if (Fichier == NULL) return false;

Et donc on devrait sortir...

Avec un code si compliqué, une seule solution: le débugger.

Peux tu zipper ton projet (avec tous les fichiers) et l'uploader?

Salut Coyotte,

Merci pour ta réponse.

J'ai retiré la boucle vue qu'il n'y a qu'un seul fichier, la boucle était là pour un autre exercice où il y'avait 3 fichiers, ici ce n'est pas le cas.

Le problème maintenant, s'est que le code n'arrive pas à lire dans le fichier txt.

La lecture se fait bien et renvoie bien ce qu'il lit ici :

Code :

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

1
2
3
4
void CChiens::Afficher()const
{
	printf("- Classifications : %s\n",Nom());
}

L'accesseur Nom() :

Code :

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

1
2
3
4
const char* CChiens::Nom() const
{
	return m_Nom.Chaine();
}

Voici le fichier zippé demandé (attention il y'a deux librairies supplémentaires à mettre dans VC98 qui s'appellent BasicConsole.lib et BasicConsoleD.lib)

S'est Chiens qui est l'exerice mais je me base sur Véhicule qui est un exerice complet et fait par le Prof.

Un tout grand merci pour ton dévouement.

beegees

[coyotte507]

Salut,

normalement dans ton zip ChiensToUseDD je devrais avoir les fichiers .cpp et .h?

Edit:

Ne t'inquiète pas pour le fichier <BasicConsole>, apparement ca correspond à <cstdio> et <cstdlib> et <cstring>.
Il y a certaines horreurs dans le code du prof, le main qui retourne un void.

Pour compiler ça sous MinGW, j'ai du modifier pas mal de choses...

Enfin le code du prof marche, ce qu'il manque maintenant c'est ton code à débugger.

[beegees]

Salut,

normalement dans ton zip ChiensToUseDD je devrais avoir les fichiers .cpp et .h?

Salut,

Normalement ils sont dans ChiensDD (ChiensToUseDD\ChiensDD\ChiensDD)

Si tu ne les trouves vraiment pas, je renverrais.

Merci pour ton aide (je te revaudrai cela !)
beegees

[coyotte507]

Salut,

non, j'ai juste un fichier chiens.txt, et un fichier ChiensDD.dsw
D'ailleurs tu peux vérifier toi-même!

[beegees]

Salut,

non, j'ai juste un fichier chiens.txt, et un fichier ChiensDD.dsw

Salut,

Excuse-moi alors.

Voici les fichiers demandés.

Merci pour tout.

beegees

[coyotte507]

Salut,

donc après les petites modifications pour faire tourner le programme sous MinGW, j'ai ceci en output:

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
Tableau des spécifications de "chiens.txt"
(null) n°1 :
- Classifications : Groupe 2 - Section 1
(null) n°2 :
- Classifications : POUBELLE
(null) n°3 :
- Classifications : POUBELLE
(null) n°4 :
- Classifications : POUBELLE
(null) n°5 :
- Classifications : POUBELLE
(null) n°6 :
- Classifications : POUBELLE
(null) n°7 :
- Classifications : POUBELLE
(null) n°8 :
- Classifications : POUBELLE
(null) n°9 :
- Classifications : POUBELLE
(null) n°10 :
- Classifications : POUBELLE

Qu'est-ce que je devrais obtenir?

[beegees]

Salut Coyotte,

Moi je n'obtiens rien excepté la phrase "press any key to continue...".

comment as-tu fait pour obtenir celà

Tu as fait des modifs dans mon code ? (tu pouvais of course)

Mais je pense en lisant ton message, que tu fais quelque modifs pour l'utiliser avec ton compilo.

J'attends tes news.

Un tout grand merci pour ton aide.

beegees

Salut,

donc après les petites modifications pour faire tourner le programme sous MinGW, j'ai ceci en output:

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
Tableau des spécifications de "chiens.txt"
(null) n°1 :
- Classifications : Groupe 2 - Section 1
(null) n°2 :
- Classifications : POUBELLE
(null) n°3 :
- Classifications : POUBELLE
(null) n°4 :
- Classifications : POUBELLE
(null) n°5 :
- Classifications : POUBELLE
(null) n°6 :
- Classifications : POUBELLE
(null) n°7 :
- Classifications : POUBELLE
(null) n°8 :
- Classifications : POUBELLE
(null) n°9 :
- Classifications : POUBELLE
(null) n°10 :
- Classifications : POUBELLE

Qu'est-ce que je devrais obtenir?

[coyotte507]

Salut,

en fait j'ai mis le main en int:

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
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include "chiens.h"
 
//eviter les doublons de race
 
int main()
{
    long n;
 
    CTableauGenerique	TabClassifications((const CGenerique&)CTabClassifications());
 
    CTabClassifications	Classifications;
 
    if (!Classifications.Charger("chiens.txt"))printf("pas ok");
    //Classifications.Trier();
    TabClassifications.Ajouter(Classifications);
 
    for (n=0; n < TabClassifications.Nombre(); n++)
    {
        printf("\n\nTableau des spécifications de \"chiens.txt\"\n");
        ((CTabClassifications&)TabClassifications.Element(n)).Afficher();
    }
 
    return 0;
}

J'ai remplacé #include <BasicConsole.h> par :

Code :

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

1
2
3
#include <cstdio>
#include <cstdlib>
#include <cstring>

Et vu que j'avais des problèmes insolubles avec les private/public, j'ai supprimé la déclaration friend (ou il manquait le mot 'class' d'ailleurs) dans le fichiers generique.h, et tout en haut du fichier generique.h j'ai rajouté cette ligne:

Code :

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

#define private public

[coyotte507]

Réflexion faite, peut être que le problème vient de TabClassifications.Nombre(). As-tu essayé de l'afficher pour voir ce qu'elle contenait?
Si elle contient 0, alors c'est normal que rien ne s'affiche...

[beegees]

Réflexion faite, peut être que le problème vient de TabClassifications.Nombre(). As-tu essayé de l'afficher pour voir ce qu'elle contenait?
Si elle contient 0, alors c'est normal que rien ne s'affiche...

Salut Coyotte,

Un tout GRAND merci pour ton aide (surtout un Dimanche).

J'ai découvert une première erreur qui est que j'avais choisis "Win32 console application" au lieu de "Win32 application" et s'est pour ça que j'obtenais :

press any key to continue...

Ce matin, j'ai aussi pensé que s'était Nombre qui posait problème.

Ce que je fais s'est :

Code :

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

1
2
3
4
5
long CTableauGenerique::Nombre() const
{
	return m_Nombre;
	printf("m_Nombre vaut %ld",m_Nombre);
}

Donc je met un printf dans le modificateur de Nombre() mais je n'obtiens rien à l'output, ais-je fait une erreur ?

J'édite ici : maintenant il lit dans le fichier je l'ai mis dans le répertoire qui contient le debug, on a donc le même résultat. donc ça marche

Comprends tu ce programme ?

Moi ce que je ne comprends pas s'est pourquoi on travaille avec POUBELLE au début du programme.

Enocre un tout grand merci pour ton aide.

beegees