Discussion :

[snake264]

Bonjour,

Je me suis fais un petit jeu et lors de la compilation j'ai ces deux warning et je ne comprend pas pourquoi:

Code :

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

1
2
xml_score.cpp(71): warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
xml_score.cpp(74): warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

Voici le 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
162
163
164
165
166
167
 
#include "xml_score.h"
 
CXMLScore::CXMLScore ()
{
 
}
 
CXMLScore::~CXMLScore ()
{
	xmlFreeDoc (m_pDocument);
}
 
// Chargement du fichier XML contenant les niveaux
bool CXMLScore::Charger (const char* szFilename)
{
	m_szFilename = std::string (szFilename);
	// Parse le document XML et créé l'arbre DOM
	m_pDocument = xmlParseFile (szFilename);
 
	// Récupère l'élément racine du document
	xmlNode* pScores = xmlDocGetRootElement (m_pDocument);
	if ((!xmlStrcmp (pScores->name, (const xmlChar *)"scores")))
		Scores (pScores);
 
	return true;
}
 
bool CXMLScore::Sauver ()
{
	// Sauvegarde du fichier XML
	xmlSaveFile (m_szFilename.c_str (), m_pDocument);
 
	return true;
}
 
bool CXMLScore::AjouterScore (SScore Score)
{
	xmlNode* pScores = xmlDocGetRootElement (m_pDocument);
	xmlNode* pText;
 
	// Création d'un noeud text
	pText = xmlNewText ((const xmlChar *) "\t");
	// Ajout à l'élément pScores le noeud text
	xmlAddChild (pScores, pText);
	char szBuffer [16];
 
	// Création d'un élément score
	xmlNode* pScore = xmlNewChild (pScores, 0, (const xmlChar *) "score", 0);
 
	// Ajout d'un nouvel élément nommé "score"
	for (std::list<SJoueur>::const_iterator JoueurIt = Score.m_Joueur.begin ();
		JoueurIt != Score.m_Joueur.end ();
		JoueurIt++)
	{
		pText = xmlNewText ((const xmlChar *) "\n\t\t");
		xmlAddChild (pScore, pText);
 
		xmlNode* pJoueur = xmlNewChild (pScore, 0, (const xmlChar *) "joueur", 0);
		xmlNewProp (pJoueur, (const xmlChar *) "nom", (const xmlChar *) JoueurIt->m_szNom.c_str ());
		memset (szBuffer, '\0', 16);
		sprintf (szBuffer, "%d", JoueurIt->m_uiScore);
		xmlNewProp (pJoueur, (const xmlChar *) "score", (const xmlChar *) szBuffer);
		memset (szBuffer, '\0', 16);
		sprintf (szBuffer, "%d", JoueurIt->m_uiNiveau);
		xmlNewProp (pJoueur, (const xmlChar *) "niveau", (const xmlChar *) szBuffer);
	}
	pText = xmlNewText ((const xmlChar *) "\n\t");
	xmlAddChild (pScore, pText);
 
	pText = xmlNewText ((const xmlChar *) "\n");
	xmlAddChild (pScores, pText);
 
	return true;
}
 
// Parcours un élément 'scores'
void CXMLScore::Scores (xmlNode* pScores)
{
	xmlNode* pScore = pScores->children;
	do
	{
		if (pScore->type == XML_ELEMENT_NODE)
			if ((!xmlStrcmp (pScore->name, (const xmlChar *)"score")))
				m_Scores.insert (Score (pScore));
	}
	while ((pScore = pScore->next) != 0);
}
 
// Parcours un élément 'score'
SScore CXMLScore::Score (xmlNode* pScore)
{
	SScore Score;
 
	xmlNode* pJoueur = pScore->children;
	if (!pJoueur)
		return Score;
 
	do
	{
		if (pJoueur->type == XML_ELEMENT_NODE)
			if ((!xmlStrcmp (pJoueur->name, (const xmlChar *)"joueur")))
				Score.m_Joueur.push_back (Joueur (pJoueur));
	}
	while ((pJoueur = pJoueur->next) != 0);
 
	return Score;
}
 
// Parcours un élément joueur
SJoueur CXMLScore::Joueur (xmlNode* pJoueur)
{
	SJoueur Joueur;
 
	xmlElement* pElementJoueur = (xmlElement*) pJoueur;
	xmlAttribute* pAttribute = pElementJoueur->attributes;
	if (!pAttribute)
		return Joueur;
 
	do
	{
		if (pAttribute->type == XML_ATTRIBUTE_NODE)
		{
			if ((!xmlStrcmp (pAttribute->name, (const xmlChar *)"nom")))
				Joueur.m_szNom = std::string ((const char*) xmlGetProp (pJoueur, pAttribute->name));
			else if ((!xmlStrcmp (pAttribute->name, (const xmlChar *)"score")))
				Joueur.m_uiScore = atoi ((const char*) xmlGetProp (pJoueur, pAttribute->name));
			else if ((!xmlStrcmp (pAttribute->name, (const xmlChar *)"niveau")))
				Joueur.m_uiNiveau = atoi ((const char*) xmlGetProp (pJoueur, pAttribute->name));
		}
	}
	while ((pAttribute = (xmlAttribute*) pAttribute->next) != 0);
 
	return Joueur;
}
 
// Redéfinition de l'opérateur < pour comparer deux SScore afin que le conteneur set puisse trier les meilleurs scores
inline bool operator < (SScore Score1, SScore Score2)
{
	unsigned int uiScore1 = 0, uiScore2 = 0;
 
	for (std::list<SJoueur>::iterator it = Score1.m_Joueur.begin ();
		 it != Score1.m_Joueur.end (); it++)
		uiScore1 += it->m_uiScore;
 
	for (std::list<SJoueur>::iterator it = Score2.m_Joueur.begin ();
		 it != Score2.m_Joueur.end (); it++)
		uiScore2 += it->m_uiScore;
 
	return uiScore1 < uiScore2;
}
 
// Redéfinition de l'opérateur > pour comparer deux SScore afin que le conteneur set puisse trier les meilleurs scores
inline bool operator > (SScore Score1, SScore Score2)
{
	unsigned int uiScore1 = 0, uiScore2 = 0;
 
	for (std::list<SJoueur>::iterator it = Score1.m_Joueur.begin ();
		 it != Score1.m_Joueur.end (); it++)
		uiScore1 += it->m_uiScore;
 
	for (std::list<SJoueur>::iterator it = Score2.m_Joueur.begin ();
		 it != Score2.m_Joueur.end (); it++)
		uiScore2 += it->m_uiScore;
 
	return uiScore1 > uiScore2;
}

Je développe sous visual studio 2008. Merci de votre aide.

[coyotte507]

Salut,

Apparement c'est juste un warning pour dire que la fonction sprintf est "dépassée", et que pour plus de sécurité il faudrait utiliser sprintf_s qui est sûrement sécurisée.

Mais il n'y a aucun problème si on fait attention en s'en servant. D'ailleurs MinGW ne se plaint pas.

Par contre je sais pas comment enlever le warning qui est génant...

[JolyLoic]

L'idéal serait quand même de remplacer sprintf et les char* par des flux est des strings.

Code :

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

sprintf (szBuffer, "Score = %d", JoueurIt->m_uiScore);

Devient par exemple :

Code :

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

1
2
3
4
 
ofstream ofs;
ofs << "Score = " << JoueurIt->m_uiScore;
string result = ofs.str();

[ram-0000]

Par contre je sais pas comment enlever le warning qui est génant...

En définissant _CRT_SECURE_NO_WARNINGS lors de la compilation dans les options du projet

[zais_ethael]

L'ennui avec ça, c'est que sprintf_s est spécifique Visual C++, elle n'existe normalement pas dans d'autres compilos. La version sécurisée officielle c'est snprintf, malheureusement elle fait partie du C99 que Visual C++ n'implémente pas pour un sous .
Donc si tu veux que ce soit sécurisé ET portable, ben il faut utiliser du C++ (de toutes façons la gestion des chaines de caractères en C a toujours été une aberration).

[snake264]

A oui en effet sa marche avec sprintf_s (que je ne connaissais pas) sinon désolé mais j'ai un autre problème cette fois-ci avec ces autres codes:

Code :

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

1
2
3
4
5
6
entite.h(31) : error C2248: 'CEntityManager::Kill' : impossible d'accéder à private membre déclaré(e) dans la classe 'CEntityManager'
ctrl_entite.h(71) : voir la déclaration de 'CEntityManager::Kill'
ctrl_entite.h(44) : voir la déclaration de 'CEntityManager'
fx.h(23) : error C2248: 'CParticleManager::Kill' : impossible d'accéder à private membre déclaré(e) dans la classe 'CParticleManager'
ctrl_particule.h(32) : voir la déclaration de 'CParticleManager::Kill'
ctrl_particule.h(23) : voir la déclaration de 'CParticleManager'

Voici le code entite.h:

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
#ifndef ENTITE_H
#define ENTITE_H
 
#include "ctrl_entite.h"
#include "util.h"
 
typedef enum
{
	ENTITE_NULL = 0,
	ENTITE_MIN = 1,
	ENTITE_BONUS = 1,
	ENTITE_ARME,
	ENTITE_ENNEMI,
	ENTITE_JOUEUR,
	ENTITE_MAX
} EEntiteType;
 
//! Entité générique, non instanciable
class CEntite
{
	//! Seul la fonction Kill peu accéder aux données membres de la classe, donc c'est le seul qui puisse créer des instances de CEntite, cependant elle est non instanciable, et détruire des instances y compris de classes dérivées
	friend void CEntityManager::Kill (unsigned int uiIndex);
 
protected:
	CTimer m_Timer;
	CVecteur m_PositionI, m_PositionF;
	CVecteur m_VitesseI, m_VitesseF;
	CVecteur m_Acceleration;
	int m_iBouclier;
	unsigned int m_uiPoint;
 
	//! Permet de déterminer si une entité en dans l'écran de jeu ou non
	bool EstDansEcran (CVecteur Position, float fRayon) const;
 
	CEntite ();
	virtual ~CEntite () {}
 
public:
	//! Retourne la texture de l'entité
	virtual unsigned int GetTexture () const = 0;
	//! Retourne les dommages de l'entités
	virtual int GetDommage () const = 0;
	//! Met à jour l'entité
	virtual void Update ();
	//! Recupère le type de l'entité
	virtual EEntiteType GetType () const = 0;
	//! Retourne la taille de l'entité
	virtual float GetTaille () const = 0;
	//! Ajout des dommages à l'entité
	virtual void AddDommage (int iDommage);
 
	//! Modification de la position de l'entité
	void Deplacer (const CVecteur & Deplacement) {m_PositionI += Deplacement;}
	//! Retourne la position de l'entité
	CVecteur GetPosition () const {return m_PositionF;}
	//! Positionne l'entité à la position indiquée par Position
	void SetPosition (const CVecteur & Position) {m_PositionF = Position;}
	//! Retour la valeur de l'entité
	int GetBouclier () const {return m_iBouclier;}
	//! Inicialisation du bouclier de l'entité
	void SetBouclier (int iBouclier) {m_iBouclier = iBouclier;}
};
 
#endif // ENTITE_H

Le code ctrl_entite.h:

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
#ifndef CTRL_ENTITE_H
#define CTRL_ENTITE_H
 
//! Le jeu est limité à CTRL_ENTITE_NOMBRE entités simultanément.
//! Limité le nombre d'entités permet notamment de fixer un plafond aux 
//! ressources réquisent par le jeu, tout en améliorant les performences.
//! En effet, on aurait très bien plus ne pas fixer de limite en 
//! utilisant une liste chainé ou un verteur de données cependant dans 
//! les deux cas, on aura notez une grosse perte de performance du 
//! principalement à des coups de réallocation dynamique (transparent si
//! l'on utilise la STL avec std::list ou stl::vector)
#define CTRL_ENTITE_NOMBRE 96
 
#include "util.h"
 
class CEntite;
class CEntiteArme;
class CEntiteBonus;
class CEntiteEnnemi;
class CEntiteJoueur;
 
//! \brief Cette structure permet de sauvegarder le nombre 
//! d'énnemi créé et détruit total et pour le niveau. 
//! on utilise cette structure pour déterminer la fin d'une partie
typedef struct
{
	unsigned int m_uiEnnemiCree;
	unsigned int m_uiEnnemiDetruit;
	unsigned int m_uiEnnemiCreeTotal;
	unsigned int m_uiEnnemiDetruitTotal;
} SStatistique;
 
//! Le gestionnaire d'entités
class CEntityManager
{
private:
	static CEntityManager *m_pEntityManager;
 
	//! Notre tableau de pointeur vers des entités.
	//! On utilise des pointeurs sur entités afin de profiter du mécanisme
	//! de l'héritage avec des fonctions virtuelles. En clair, les instances
	//! pointer par ce tableau, pointe vers des instances de classes dérivés
	//! de la classe CEntite. On utilise des fonctions virtuelles déclarés
	//! dans la classe CEntite pour accéder aux fonctions de même prototype
	//! déclaré dans les classes dérivés de CEntite.
	CEntite *m_pEntite[CTRL_ENTITE_NOMBRE];
 
	//! Nombre d'ennemis créés et détruits dans le niveau et la partie
	SStatistique m_Statistique;
 
	//! Recherche d'un emplacement libre dans la table des entités
	int GetIndexLibre () const;
	//! Permet de déterminer si une entité en dans l'écran de jeu ou non
	bool EstDansEcran (CVecteur Position, float fTaille) const;
	//! Mise à jours de entités
	void UpdateEntite ();
	//! Gestion des collisions entre entités : Il y a t'il des entités qui se chevauchent et comment réagir
	void GererCollision ();
	//! Annule le propriétaire pEntite, de toutes entités qui possédent un propriétaire
	bool AnnulerProprietaire (CEntite* pEntite);
 
	void Kill (unsigned int uiIndex);
 
	//! Constructeur
	CEntityManager ();
	//! Desctructeur
	~CEntityManager ();
 
public:
	//! Creation ou récupération de l'instance de gestionnaire d'entités.
	static CEntityManager* Create ();
	//! Suppression de l'instance de gestionnaire d'entités si elle existe.
	static void	Kill ();
 
	//! Création d'une instance d'entité arme.
	//! Si le nombre maximum, l'entité est atteind, ces fonctions retournent 0. Il faut donc contrôler son retour.
	CEntiteArme* CreateArme ();
	//! Création d'une instance d'entité bonus.
	//! Si le nombre maximum, l'entité est atteind, ces fonctions retournent 0. Il faut donc contrôler son retour.
	CEntiteBonus* CreateBonus ();
	//! Création d'une instance d'entité ennemi.
	//! Si le nombre maximum, l'entité est atteind, ces fonctions retournent 0. Il faut donc contrôler son retour.
	CEntiteEnnemi* CreateEnnemi ();
	//! Création d'une instance d'entité joueur.
	//! Si le nombre maximum, l'entité est atteind, ces fonctions retournent 0. Il faut donc contrôler son retour.
	CEntiteJoueur* CreateJoueur ();
 
	//! Offre un accès au tableau de pointeur sur entité. Ce type d'opération
	//! est une source potencielle de risques. 
	//! Pour les limités, nous prenons soin de déclarer "const" le type de 
	//! sortie afin de garantir qu'à l'utilisation, ce pointeur et sa valeur
	//! ne seront pas modifié.
	const CEntite* const GetEntiteParIndex (unsigned int uiIndex) const;
	//! Offre un accès aux statistiques du projet.
	const SStatistique & GetStatistique () const {return m_Statistique;}
 
	//! Initialisation du gestionnaire d'entité.
	void Init ();
	//! Mise à jour du gestionnaire d'entité.
	void Update ();
};
 
#endif //CTRL_ENTITE_H

Le code fx.h:

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
#ifndef FX_H
#define FX_H
 
#include "ctrl_particule.h"
#include "entite.h"
#include "fx_particule.h"
#include "util.h"
 
#define PARTICULE_NOMBRE 128
 
//! Classe générique de générateurs de particules
class CParticleSystem
{
	friend void CParticleManager::Kill (unsigned int uiIndex);
 
protected:
	CEntite* m_pProprietaire;
	CParticule *m_pParticule[PARTICULE_NOMBRE];
	float m_fTailleParticule;
	unsigned int m_uiTexture;
	bool m_bSupprime;
	CTimer m_Timer;
	CCouleur m_Couleur;
 
	//! Recherche d'un emplacement libre dans la table des particules.
	int GetIndexLibre () const;
	//! Vérifie si le générateur de particules est dans l'écran.
	bool EstDansEcran (CVecteur Position, float fRayon) const;
 
	CParticleSystem ();
	virtual ~CParticleSystem ();
 
public:
	//! Offre un accès au tableau de pointeur sur particule. Ce type d'opération
	//! est une source potencielle de risques. 
	//! Pour les limités, nous prenons soin de déclarer "const" le type de 
	//! sortie afin de garantir qu'à l'utilisation, ce pointeur et sa valeur
	//! ne seront pas modifié.
	const CParticule* const GetParticuleParIndex (unsigned int uiIndex) const;
 
	//! Mise à jour du générateur de particules.
	virtual void Update () = 0;
	//! Initialisation du générateur de particules.
	virtual void Init () = 0;
	//! Faut t'il supprimer le générateur ?
	bool GetSupprime () const {return m_bSupprime;}
	//! Retourne la texture du générateur de particules.
	unsigned int GetTexture () const {return m_uiTexture;}
	//! Retourne la couleur de l'entité.
	CCouleur GetCouleur () const {return m_Couleur;}
	//! Retourne la taille des particules.
	float GetTaille () const {return m_fTailleParticule;}
};
 
#endif //FX_H

Et enfin le code ctrl_particule.h:

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
#ifndef CTRL_PARTICULE_H
#define CTRL_PARTICULE_H
 
#define CTRL_GENERATEUR_PARTICULE_NOMBRE 32
#define FICHIER_TEXTURE_PARTICULE "./data/image/particule.tga"
 
class CEtoile;
class CFumee;
class CExplosion;
class CParticleSystem;
 
//! Gestionnaires des générateurs de particules
class CParticleManager
{
private:
	static CParticleManager *m_pParticleManager;
 
	CParticleSystem *m_pGenParticule[CTRL_GENERATEUR_PARTICULE_NOMBRE];
	unsigned int m_uiTexture;
	bool m_bActif;
 
	int GetIndexLibre () const;
	void Kill (unsigned int uiIndex);
 
	CParticleManager ();
	~CParticleManager ();
 
public:
	//! Creation ou récupération de l'instance du gestionnaire de générateurs de particules.
	static CParticleManager* Create ();
	//! Suppression de l'instance de gestionnaire de générateurs de particules si elle existe.
	static void	Kill ();
 
	//! Accès aux générateurs de particules.
	const CParticleSystem* GetGenerateurParIndex (unsigned int uiIndex) const;
 
	//! Seul cette fonction permet la création d'une instance d'effet de défilement d'étoiles.
	CEtoile* CreateEtoile ();
	//! Seul cette fonction permet la création d'une instance d'effet de fumée.
	CFumee* CreateFumee ();
	//! Seul cette fonction permet la création d'une instance d'explosion.
	CExplosion* CreateExplosion ();
 
	//! Mise à jour du gestionnaire de générateurs de particules.
	void Update ();
};
 
#endif //CTRL_PARTICULE_H

Voila c'est un projet que je dois terminer pour lundi prochain et la je suis en pleine phase de débuggage et comme je suis vraiment pas familier avec les spécificitées de visual studio et que je dois le faire avec sa et bien je rame en tout cas merci

[zais_ethael]

D'après les messages d'erreur ça a l'air assez simple: tu essaies d'accéder à une variable privée en dehors de la classe.
Néanmoins, tu comprendras que c'est un peu difficile de vérifier dans le code. Quand on poste du code il est demandé de fournir un exemple minimal qui reproduit l'erreur, pas un roman (ça doit être marqué quelque part dans les règles du forum).
Certains posteurs ne s'en formalisent pas, mais d'autres comme moi sont assez feignants quand il s'agit de lecture de source