Discussion :

[beegees]

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 :

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

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 :

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

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 :

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

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
#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

[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 ?

[Médinoc]

Code :

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

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?

[Feriaman]

1) CChaine

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

[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

assertion failed

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

Code :

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

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 !

[beegees]

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++.

Code :

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

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

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 :

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

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

[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?