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