Mon programme tourne fou

Version imprimable

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:

TabClassifications.Ajouter(Classifications);

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

Code:

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:

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:

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

26/04/2008, 20h00
droggo

Fao,

La boucle

Code:

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

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

Citation:

Envoyé par droggo

Fao,

La boucle

Code:

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:

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

Salut à tous !
Citation:
Envoyé par beegees
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:

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:

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

26/04/2008, 20h25
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
26/04/2008, 20h30
coyotte507

Salut,

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

Citation:

Envoyé par coyotte507

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:

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:

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

26/04/2008, 20h46
coyotte507

Salut,

heureux de te revoir aussi!

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

Peux-tu la montrer?

Citation:

Envoyé par coyotte507

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:

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:

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:

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:

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

26/04/2008, 20h58
coyotte507

Salut,

c'est bizarre:

Code:

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?
27/04/2008, 08h03
beegees
Citation:

Envoyé par coyotte507

Salut,

c'est bizarre:

Code:

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:

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

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
27/04/2008, 12h00
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.
27/04/2008, 12h13
beegees

Citation:

Envoyé par coyotte507

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
27/04/2008, 12h24
coyotte507

Salut,

non, j'ai juste un fichier chiens.txt, et un fichier ChiensDD.dsw
D'ailleurs tu peux vérifier toi-même! ;)
27/04/2008, 12h34
beegees

Citation:

Envoyé par coyotte507

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

Salut,

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

Code:

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?

Salut Coyotte,

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

comment as-tu fait pour obtenir celà :roll:

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
Citation:
Envoyé par coyotte507
Salut,

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

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?

Salut,

en fait j'ai mis le main en int:
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 #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:

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: :mouarf:

Code:

#define private public

27/04/2008, 13h06
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...
27/04/2008, 13h18
beegees
Citation:

Envoyé par 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...

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 :

Citation:

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:

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 :mouarf: je l'ai mis dans le répertoire qui contient le debug, on a donc le même résultat. donc ça marche :yaisse2:

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

Salut,

Dans ce cas change ta fonction CChargeurFichierTexte::Charger:

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
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) 
	{
	    printf("Impossible d'ouvrir le fichier %s\n", NomFichier);
	    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);
				puts ("La fonction FctnTraiterLigne n'a pas marché");
				return false;
			}
		}
	}
	fclose(Fichier);
	return true;
}

Ca devrait afficher la cause de pourquoi il n'arrive pas à charger.

Citation:
Envoyé par coyotte507
Salut,

Dans ce cas change ta fonction CChargeurFichierTexte::Charger:
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 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) { printf("Impossible d'ouvrir le fichier %s\n", NomFichier); 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); puts ("La fonction FctnTraiterLigne n'a pas marché"); return false; } } } fclose(Fichier); return true; }
Ca devrait afficher la cause de pourquoi il n'arrive pas à charger.
Salut Coyotte,

Je suis vraiment désolé, ça marche maintenant :yaisse2:

J'avais juste pas mis le fichier txt au bon endroit, maintenant il lit en effet le champ 1 (qui est le groupe - section) du fichier txt.

J'en ai 110, donc Nombre() fonctionne aussi.

T'es trop super sympa et trop efficace aussi, un super grand :merci: pour ton aide so precious et très bon Dimanche à toi.

beegees

27/04/2008, 13h34
coyotte507

Salut,

Tu me fais trop d'honneur avec tes remerciements :roll:
Content que ça marche, et bonne journée!
27/04/2008, 13h35
beegees

Citation:

Envoyé par coyotte507

Salut,

Tu me fais trop d'honneur avec tes remerciements :roll:
Content que ça marche, et bonne journée!

Re,

S'est mérité, tu iras loin toi !

Très bonne journée à toi aussi.

beegees