Bonjour tout le monde,

J'essaie d'afficher des données mais à la place d'avoir des chaines de caractère, j'ai des chaines vides.

Le problème doit venir de 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
19
20
21
bool CTraitementFestivals::TraiterLigne(const CChargeurFichierTexte& Chargeur)
{
	if (Chargeur.NombreChamps() < 2) return true;
	const char*	Code = Chargeur.Champs(0);
	const char* Chaine = Chargeur.Champs(1);
	const char* NomActeur = Chargeur.Champs(2);
 
	if(!m_Festivals.Ajouter(CRecompense(Chaine,NomActeur)))return true;
 
	// Affichage des deux tableaux
	for (long n=0; n < m_Festivals.Nombre();n++)
	{
		CRecompense& Rec = m_Festivals.Element(n);
		if((strcmp(Code,"RF") ==0)||(strcmp(Code,"RR") ==0) || (strcmp(Code,"RA")==0))
		{
			printf("%s\n",Rec.Nom());
		}
	}
 
	return true;
}
Si je fais :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
printf("%s\n",Chargeur.Champs(1));
ou

Code : Sélectionner tout - Visualiser dans une fenêtre à part
printf("%s\n",Chaine());
ça fonctionne.

Mais normalement il faut appeler l'accesseur et afficher le résultat via cet accesseur.

Je vous laisse une partie de mon code :

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 "CinemaniaDD.h"
 
//////////////////
// CRecompense ///
//////////////////
 
CRecompense::CRecompense()
{
}
 
CRecompense::CRecompense(const CRecompense& Source)
:CGenerique(Source),m_Nom(Source.m_Nom),m_NomActeur(Source.m_NomActeur)
{
}
 
CRecompense::CRecompense(const char* UnNom,const char* UnActeur)
{
}
 
CRecompense::~CRecompense()
{
}
 
CGenerique* CRecompense::Cloner() const
{
	return new CRecompense(*this);
}
 
bool CRecompense::EstValide() const
{
	return true;
 
}
 
 
bool CRecompense::GereUnicite() const
{
	return true;
}
 
int CRecompense::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	if(TypeComparaison == 0) return m_Nom.Comparer(((const CRecompense&)Autre).m_Nom,Comparaison_TriCroissantNonStrict);
	if(TypeComparaison == 1) return m_Nom.Comparer(((const CRecompense&)Autre).m_Nom,Comparaison_TriCroissantNonStrict);
	return 0;
 
}
 
const char* CRecompense::Nom() const
{
	return m_Nom.Chaine();
}
 
bool CRecompense::Mot(const char* UnNom)
{
	if((strlen(UnNom)<1)&&(UnNom==NULL))return false;
	m_Nom = UnNom;
	return true;
}
 
//////////////////////
// CTabRecompenses ///
//////////////////////
 
CTabRecompenses::CTabRecompenses()
:CTableauGenerique(CRecompense())
{
}
 
CTabRecompenses::CTabRecompenses(const CTabRecompenses& Source)
:CTableauGenerique(Source)
{
}
 
CTabRecompenses::~CTabRecompenses()
{
}
 
CGenerique* CTabRecompenses::Cloner() const
{
	return new CTabRecompenses(*this);
}
 
CRecompense& CTabRecompenses::Element(long Indice) const
{
	return (CRecompense&)CTableauGenerique::Element(Indice);
}
 
long CTabRecompenses::Indice(const char* UnNom) const
{
	return CTableauGenerique::Indice(CRecompense(UnNom,NULL));
}
 
bool CTabRecompenses::Ajouter(CRecompense& Modele)
{
	return CTableauGenerique::Ajouter(Modele);
}
 
void CTabRecompenses::Trier(long TypeComparaison)
{
	CTableauGenerique::Trier(1);
}
 
//////////////////////////
// CTraitementFestivals //
//////////////////////////
 
CTraitementFestivals::CTraitementFestivals()
{
}
 
CTraitementFestivals::~CTraitementFestivals()
{
}
 
bool CTraitementFestivals::Charger(const char* NomFichier)
{
	CChargeurFichierTexte Chargeur;
 
	if(!Chargeur.Charger(NomFichier,'\t',FctnTraiterLigne,this))return false;
}
 
/* static */ bool CTraitementFestivals::FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTraitementFestivals*)Contexte)->TraiterLigne(Chargeur);
}
 
bool CTraitementFestivals::TraiterLigne(const CChargeurFichierTexte& Chargeur)
{
	if (Chargeur.NombreChamps() < 2) return true;
	const char*	Code = Chargeur.Champs(0);
	const char* Chaine = Chargeur.Champs(1);
	const char* NomActeur = Chargeur.Champs(2);
 
	if(!m_Festivals.Ajouter(CRecompense(Chaine,NomActeur)))return true;
 
	// Affichage des deux tableaux
	for (long n=0; n < m_Festivals.Nombre();n++)
	{
		CRecompense& Rec = m_Festivals.Element(n);
		if((strcmp(Code,"RF") ==0)||(strcmp(Code,"RR") ==0) || (strcmp(Code,"RA")==0))
		{
			printf("%s\n",Rec.Nom());
		}
	}
 
	return true;
 
	/*Donc là j'ai défini le faux-frère, maintenant je vais en prendre la référence, s'est une 
	référence de faux-frère, je sais qu'il existe parce que "Ajouter" m'a renvoyé VRAI, donc je 
	vais rechercher un élément en fonction de l'indice que j'aurai trouvé via une recherche sur le 
	mot donc j'appelle Indice qui me renvoie l'indice par rapport au mot et avec cet indice 
	j'accède à un élément et je note cette référence dans cette variable locale que j'appelle 
	ReferenceFF */
 
	/*Il va donc chercher un mot trouvé dans le texte et voir si il correspond à un faux frère dans la liste des ff
	si s'est le cas, il l'ajoute*/
 
 
}
Un tout grand merci pour votre aide.

beegees