[VC++]Debug Assertion Failled

Version imprimable

Bonjour tout le monde,

J'ai un gros problème lors de l'exécution de mon programme.

J'obtiens ce message d'erreur :

Voir attaché svp.

Qaund j'essaie un debug, mon PC ralentit très fort, comme-ci on irait dans une partie de la mémoire qui n'est pas autorisée :?

EDIT: je viens avec du neuf :

Le problème se situe ici :

Code:

1
2
3
4
5
6
7
CRecompense::CRecompense(const char* UnCodeRec,const char* UnNomRec,const char* UnNomActeurRec)
:m_CodeRecompense("Mauvais1"),m_NomRecompense("mauvais2"),m_NomActeur("Mauvais3")
{
	CodeRecompense(UnCodeRec);
	NomRecompense(UnNomRec);
	NomActeur(UnNomActeurRec);
}

car quand je mets en commentaire ceci :

Code:

1
2
3
CodeRecompense(UnCodeRec);
	NomRecompense(UnNomRec);
	NomActeur(UnNomActeurRec);

ben ça fonctionne.

Je vous laisse le code de mon .h et de mon .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
#include <BasicConsole.h>
#include "Cinemania4.h"
 
////////////////////////
// Classe CRecompense //
////////////////////////
 
CRecompense::CRecompense()
:m_CodeRecompense("Mauvais1"),m_NomRecompense("mauvais2"),m_NomActeur("Mauvais3")
{
}
 
CRecompense::CRecompense(const CRecompense& Source)
:m_CodeRecompense(Source.m_CodeRecompense),m_NomRecompense(Source.m_NomRecompense),m_NomActeur(Source.m_NomActeur)
{
}
 
CRecompense::CRecompense(const char* UnCodeRec,const char* UnNomRec,const char* UnNomActeurRec)
:m_CodeRecompense("Mauvais1"),m_NomRecompense("mauvais2"),m_NomActeur("Mauvais3")
{
	CodeRecompense(UnCodeRec);
	NomRecompense(UnNomRec);
	NomActeur(UnNomActeurRec);
}
 
CRecompense::~CRecompense()
{
}
 
CGenerique* CRecompense::Cloner() const
{
	return new CRecompense(*this);
}
 
bool CRecompense::GereUnicite() const
{
	return true;
}
 
long CRecompense::NombreClesDeTri() const
{
	return 1;
}
 
bool CRecompense::EstValide() const
{
	//je viendrai compléter après
	return true;
}
 
int CRecompense::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	if(TypeComparaison==0)
		return m_NomRecompense.Comparer(((CChaine&)Autre),Comparaison_TriCroissantNonStrict);
	return 0;
}
 
const char* CRecompense::CodeRecompense() const
{
	return m_CodeRecompense.Chaine();
}
 
const char* CRecompense::NomActeur() const
{
	return m_NomActeur.Chaine();
}
 
const char* CRecompense::NomRecompense() const
{
	return m_NomRecompense.Chaine();
}
 
bool CRecompense::CodeRecompense(const char* UnCodeRecompense)
{
	if(strlen(UnCodeRecompense)!=2)return false;
	m_CodeRecompense = UnCodeRecompense;
	return true;
}
 
bool CRecompense::NomRecompense(const char* UnNomRecompense)
{
	if((strlen(UnNomRecompense)<5)|| (UnNomRecompense == NULL)) return false;
	m_NomRecompense = UnNomRecompense;
	return true;
}
 
bool CRecompense::NomActeur(const char* UnNomActeur)
{
	if ((strlen(UnNomActeur)<1)||(UnNomActeur == NULL)) return false;
	m_NomActeur = UnNomActeur;
	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* UnNomRecompense) const
{
	return CTableauGenerique::Indice(CRecompense(UnNomRecompense,"",""));//mon constructeur spécifique de CRecompense prend trois chaine, je lui passe donc trois chaines dont deux vides
}
 
bool CTabRecompenses::Ajouter(CRecompense& Modele) 
{
	return true;
}
 
/////////////////////////
// CTraitementFichier //
////////////////////////
 
CTraitementFichier::CTraitementFichier()
{
}
 
CTraitementFichier::~CTraitementFichier()
{
}
 
bool CTraitementFichier::Charger(const char* NomFichier)
{
	CChargeurFichierTexte Chargeur;
	if(!Chargeur.Charger(NomFichier,'\t',FctnTraiterLigne,this))return false;
	return true;
}
 
/* static */ bool CTraitementFichier::FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTraitementFichier*)Contexte)->TraiterLigne(Chargeur);
}
 
bool CTraitementFichier::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((strcmp(Code,"RF") == 0)||(strcmp(Code,"RR") == 0) || (strcmp(Code,"RA")== 0))
		if(!m_Recompenses.Ajouter(CRecompense(Code,Chaine,NomActeur)))return true;
 
 
 
 
 
	return true;
 
 
}

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
#ifndef CINEMANIA_H
#define CINEMANIA_H
 
#include "generique.h"
#include "chaine.h"
 
/***************************ANALYSE******************************************
 
         - Je vais créer une classe CRecompense.
         - Une récompense est composée d'un code de deux lettres, 
           d'un nom et si s'est une récompense pour un acteur, du nom de l'acteur
 
 
*******************************************************************************/
 
 
 
class CRecompense;
class CTabRecompenses;
class CTraitementFichier;
 
 
class CRecompense : public CGenerique
{
public:
 
	//constructeurs et destructeur
	CRecompense();
	CRecompense(const CRecompense& Source);
	CRecompense(const char* UnCodeRec, const char* UnNomRec, const char* UnNomActeurRec);
	~CRecompense();
 
	CGenerique*		Cloner() const;
	bool			GereUnicite() const;
	long			NombreClesDeTri() const;
	bool			EstValide() const;
	int				Comparer(const CGenerique& Autre, long TypeComparaison) const;
 
	//les accesseurs :
	const char*		CodeRecompense() const;
	const char*		NomRecompense() const;
	const char*		NomActeur() const;
 
	//les modificateurs
	bool			CodeRecompense(const char* UnCodeRecompense);
	bool			NomRecompense(const char* UnNomRecompense);
	bool			NomActeur(const char* UnNomActeur);
 
 
	//les membres privés
private :
	CChaine			m_CodeRecompense;
	CChaine			m_NomRecompense;
	CChaine			m_NomActeur;
 
};
 
class CTabRecompenses : public CTableauGenerique
{
public:
 
	//les constructeurs et le destructeur
	CTabRecompenses();
	CTabRecompenses(const CTabRecompenses& Source);
	~CTabRecompenses();
 
	CGenerique*		Cloner() const;
	CRecompense&	Element(long Indice) const;
	long			Indice(const char* UnNomRecompense) const; //je vais rechercher si un nom de récompense est déjà présent où non pour ne pas devoir l'afficher deux fois car s'est un peu le but de l'exerice
	bool			Ajouter(CRecompense& Modele);
 
};
 
class CTraitementFichier
{
public:
	CTraitementFichier();
	~CTraitementFichier();
 
	bool Charger(const char* NomFichier);
 
private:
 
	static bool			FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte);
	bool				TraiterLigne(const CChargeurFichierTexte& Chargeur);
 
private:
	CTabRecompenses		m_Recompenses;
 
 
 
};
 
 
 
 
 
 
 
 
#endif//CINEMANIA_H

Merci d'avance pour votre aide.

beegees

21/05/2008, 11h03
befalimpertinent

Je n'ai pas regarder en détails ton code mais une question : pourquoi ne pas utiliser les std::string à la place des chaines char * à la C ?

Code:

1 2 3 4 5 6 int CRecompense::Comparer(const CGenerique& Autre, long TypeComparaison) const { if(TypeComparaison==0) return m_NomRecompense.Comparer(((CChaine&)Autre),Comparaison_TriCroissantNonStrict); return 0; }
Attention, ce cast C-style n'est pas const-correct.
Si CChaine hérite de CGenerique, tu dois utiliser static_cast< const CChaine & >(Autre) à la place.

PS: Es-tu absolument certain que ta classe CChaine est fiable?

21/05/2008, 11h38
Feriaman

1) CChaine

Citation:

Envoyé par befalimpertinent

pourquoi ne pas utiliser les std::string à la place des chaines char * à la C ?

Citation:

Envoyé par Médinoc

[CODE]PS: Es-tu absolument certain que ta classe CChaine est fiable?

Pour ma part, je crois aussi que ton problème vient des CChaine.

2) Débugueur

Mais, plutôt que de nous poster ici les sources de CChaine, je te propose de prendre un débugueur et de suivre pas à pas le déroulement de ton programme.

Ainsi tu pourras précisément localiser l'erreur.

3) Message d'erreur

Le message que tu obtiens

Citation:

assertion failed

signifie probablement que quelque part, quelqu'un (peut-être toi) a écrit un

Code:

assert(condition)

, pour vérifier quelque chose qui doit être vrai. Et que ce quelque chose est faux.

Cela arrive souvent quand on utilise mal du code de quelqu'un d'autre sans avoir bien compris comment on doit s'en servir.

4) Coder petit à petit

Par ailleurs, vu l'étendue de ton programme et le fait que cette erreur surviennent d'un seul coup, je suppose que tu as coder tout ton programme d'un bloc et que tu ne l'a compilé et exécuté qu'après.

On ne le répètera jamais assez : quand on code, et surtout si on n'est pas sur de soi, il faut travailler petit à petit :
- Tu écris quelques lignes
- Tu compiles, tu exécute
- Tu écris quelques lignes
- Tu compiles, tu exécute
- Tu écris quelques lignes
- Tu compiles, tu exécute
...

Cela présente deux avantages :
- cela te force à morceler ton code et à commencer par des parties autonomes, ce qui te servira énormément plus tard quand tu feras des modèles de données complexe.
- cela te permet de trouver les bugs facilement.

Courage !

Citation:

Envoyé par befalimpertinent

Je n'ai pas regarder en détails ton code mais une question : pourquoi ne pas utiliser les std::string à la place des chaines char * à la C ?

Salut,

Merci pour ta réponse.

ça va te paraître bizzare mais je me pose la même question :?

Dernier soir de cours si tout va bien après je peux me mettre au C++.
Citation:
Envoyé par Médinoc
Code:

1 2 3 4 5 6 int CRecompense::Comparer(const CGenerique& Autre, long TypeComparaison) const { if(TypeComparaison==0) return m_NomRecompense.Comparer(((CChaine&)Autre),Comparaison_TriCroissantNonStrict); return 0; }
Attention, ce cast C-style n'est pas const-correct.
Si CChaine hérite de CGenerique, tu dois utiliser static_cast< const CChaine & >(Autre) à la place.

PS: Es-tu absolument certain que ta classe CChaine est fiable?
Salut Medinoc,

Merci pour ta réponse.

Pour toi le problème viendrai de comparer alors ?

J'ai modifié la méthode "Comparer" avec une qui fonctionne mais ça marche toujours pas. :?

Enfin merci quand même.

beegees

Citation:

Envoyé par Feriaman

1) CChaine

Pour ma part, je crois aussi que ton problème vient des CChaine.

Voici q

2) Débugueur

Mais, plutôt que de nous poster ici les sources de CChaine, je te propose de prendre un débugueur et de suivre pas à pas le déroulement de ton programme.

Ainsi tu pourras précisément localiser l'erreur.

3) Message d'erreur

Le message que tu obtiens signifie probablement que quelque part, quelqu'un (peut-être toi) a écrit un

Code:

assert(condition)

, pour vérifier quelque chose qui doit être vrai. Et que ce quelque chose est faux.

Cela arrive souvent quand on utilise mal du code de quelqu'un d'autre sans avoir bien compris comment on doit s'en servir.

4) Coder petit à petit

Par ailleurs, vu l'étendue de ton programme et le fait que cette erreur surviennent d'un seul coup, je suppose que tu as coder tout ton programme d'un bloc et que tu ne l'a compilé et exécuté qu'après.

On ne le répètera jamais assez : quand on code, et surtout si on n'est pas sur de soi, il faut travailler petit à petit :
- Tu écris quelques lignes
- Tu compiles, tu exécute
- Tu écris quelques lignes
- Tu compiles, tu exécute
- Tu écris quelques lignes
- Tu compiles, tu exécute
...

Cela présente deux avantages :
- cela te force à morceler ton code et à commencer par des parties autonomes, ce qui te servira énormément plus tard quand tu feras des modèles de données complexe.
- cela te permet de trouver les bugs facilement.

Courage !

Salut,

Merci pour tes précieux conseils.

Je pense que il essaye d'ajouter un chaine vide et que ça passe pas, je continue à chercher.

Merci encore.

beegees

21/05/2008, 14h14
Médinoc

Peux-tu poster ta classe CChaine histoire qu'on puisse vérifier qu'elle n'a pas de bug flagrant de gestion de la mémoire?

Citation:

Envoyé par Médinoc

Peux-tu poster ta classe CChaine histoire qu'on puisse vérifier qu'elle n'a pas de bug flagrant de gestion de la mémoire?

Salut,

Voici le code demandé :

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,UnSeparateur))
		{
			if (!FctnTraiterLigne(*this,Contexte))
			{
				fclose(Fichier);
				return false;
			}
		}
	}
	fclose(Fichier);
	return true;
}

Merci
beegees

21/05/2008, 14h55
Médinoc

Je ne vois pas de redéfinition de l'opérateur = dans ton code. Très mauvais.

PS: Tu devrais faire au moins un dynamic_cast<> dans ta fonction Comparer()...
21/05/2008, 15h00
beegees

Citation:

Envoyé par Médinoc

Je ne vois pas de redéfinition de l'opérateur = dans ton code. Très mauvais.

PS: Tu devrais faire au moins un dynamic_cast<> dans ta fonction Comparer()...

Merci pour ta réponse.

je ne comprends pas bien, s'est donc dans la méthode comparer que je dois faire une transformation ?

Merci encore.

beegees
21/05/2008, 15h12
Médinoc

Non, je pense que l'erreur vient plutôt des =.

Mais aussi, ta méthode Comparer() me fait peur et ne me parait pas très fiable.
21/05/2008, 16h19
beegees

Citation:

Envoyé par Médinoc

Non, je pense que l'erreur vient plutôt des =.

Mais aussi, ta méthode Comparer() me fait peur et ne me parait pas très fiable.

tu vois où les = ?

Merci
beegees

Ici, entre autres:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
bool CRecompense::CodeRecompense(const char* UnCodeRecompense)
{
	if(strlen(UnCodeRecompense)!=2)return false;
	m_CodeRecompense = UnCodeRecompense;
	return true;
}
 
bool CRecompense::NomRecompense(const char* UnNomRecompense)
{
	if((strlen(UnNomRecompense)<5)|| (UnNomRecompense == NULL)) return false;
	m_NomRecompense = UnNomRecompense;
	return true;
}
 
bool CRecompense::NomActeur(const char* UnNomActeur)
{
	if ((strlen(UnNomActeur)<1)||(UnNomActeur == NULL)) return false;
	m_NomActeur = UnNomActeur;
	return true;
}

Ça fiche le bazar parce que ta classe CChaine n'a pas d'opérateur = redéfini...

Citation:
Envoyé par Médinoc
Ici, entre autres:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 bool CRecompense::CodeRecompense(const char* UnCodeRecompense) { if(strlen(UnCodeRecompense)!=2)return false; m_CodeRecompense = UnCodeRecompense; return true; } bool CRecompense::NomRecompense(const char* UnNomRecompense) { if((strlen(UnNomRecompense)<5)|| (UnNomRecompense == NULL)) return false; m_NomRecompense = UnNomRecompense; return true; } bool CRecompense::NomActeur(const char* UnNomActeur) { if ((strlen(UnNomActeur)<1)||(UnNomActeur == NULL)) return false; m_NomActeur = UnNomActeur; return true; }
Ça fiche le bazar parce que ta classe CChaine n'a pas d'opérateur = redéfini...
Salut Medinoc,

Un tout GRAND merci pour ton message.

En plein dans le mille !

Il fallait faire :

Code:

m_NomActeur.Chaine(UnNomActeur);

et non

Code:

m_NomActeur = UnNomActeur;

Encore un tout grand merci, t'es très fort :king:

beegees

Ou, plus simple, implémenter un opérateur = pour corriger ça... :roll:

Conformément à l'idiome copy-and-swap, on ajoute deux fonctions membres à al classe CChaine :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class CChaine
{
	...
	void Swap(CChaine &other);
	CChaine & operator= (CChaine const &src);
};
 
void CChaine::Swap(CChaine &other)
{
	//Échanger variable membre m_Chaine
	{ char * chaine = other.m_Chaine;
	other.m_Chaine = m_Chaine;
	m_Chaine = chaine; }
}
 
CChaine & CChaine::operator= (CChaine const &src)
{
	CChaine tmp(src); //copy
	Swap(tmp);        //and swap
}

On peut aussi utiliser la fonction template std::swap() de <algorithms>, et s'y conformer, ce qui donne:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <algorithm>
 
class CChaine
{
	...
 
	void Swap(CChaine &other);
	CChaine & operator= (CChaine const &src);
 
	...
};
 
namespace std
{
	template<>
	void swap< CChaine >(CChaine &a, CChaine &b)
	{
		a.Swap(b);
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
...
 
void CChaine::Swap(CChaine &other)
{
	//Échanger variable membre m_Chaine
	std::swap(m_Chaine, other.m_Chaine);
}
 
CChaine & CChaine::operator= (CChaine const &src)
{
	CChaine tmp(src); //copy
	Swap(tmp);        //and swap
}