Run-Time Check Failure #2 - Stack around the variable 'Arret' was corrupted. a eu lieu

Version imprimable

Bonjour à vous!

Je viens ce matin afin de vous faire part d'un petit problème dans ce "Jeu".
Petites précision: Le jeu marche, (il exécute un fichier .h et un fichier de prototypes .cpp)
mais lorsque le jeu se termine et qu'il affiche l'image "win.bmp", il affiche le message d'erreur suivant:
"Run-Time Check Failure #2 - Stack around the variable 'Arret' was corrupted. a eu lieu*"

Même chose quand j'utilise Escape (SDLK_ESCAPE) qui set la variable Arret à 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
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
 
#ifndef _SDLCLG_H
#define _SDLCLG_H
///////////////////////////////////////////////////////////////////////////////
// sdlclg.h
// Interface de programmation graphique pour le cours de KA0 utilisation la
// la libraire SDL 1.2.14-VC8
// Joan-Sébastien Morales, Stéphane Chassé et Etienne Forest
// Version 1.0 Création 25 octobre 2009
// Version 1.1 Modification 27 octobre 2009
//   -- Ajout de messages d'erreurs
//   -- Ajout de la fonction RafraichirFenetre
// Version 1.2 Modification 17 novembre 2009
//   -- Ajout du type ImageId
//   -- Ajout de l'énumération Evenement
//   -- Ajout de la fonction AttendreEvenement
// Version 1.21 Modification 24 novembre 2009
//   -- Correction d'un bug avec la fonction AttendreEvenement
// Version 1.3 Modification 23 septembre 2016
//   -- Conversion à SDL 2.0.4 pour Visual Studio 2015
// Version 1.31 Modification 31 octobre 2016
//   -- Correction d'un problème de création de textures à l'affichage
//      qui remplissait la RAM inutilement
///////////////////////////////////////////////////////////////////////////////
#include <SDL.h>
#include <string>
using namespace std;
 
///////////////////////////////////////////////////////////////////////////////
// Type de données utilisé pour conserver les numéros d'images
///////////////////////////////////////////////////////////////////////////////
typedef int ImageId;
 
///////////////////////////////////////////////////////////////////////////////
// Liste des événements associés au clavier
///////////////////////////////////////////////////////////////////////////////
enum Evenement
{
	EVAucun, EVQuitter, EVBas, EVHaut, EVGauche, EVDroite
};
///////////////////////////////////////////////////////////////////////////////
// Attendre
// Permet de placer le programme en attente pendant un certain temps
// Intrant: Temps: Nombre de millisecondes
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void Attendre(int Temps);
///////////////////////////////////////////////////////////////////////////////
// InitialiserAffichage
// Fait apparaître une fenêtre graphique
// IMPORTANT: InitialiserAffichage doit être appelé avant même de charger des images
//   sinon tout l'affichage sera noir.
// Intrant: Titre: Titre de la fenêtre
//			Largeur: Largeur de la fenêtre en pixels
//		    Hauteur: Hauteur de la fenêtre en pixels
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void InitialiserAffichage(string Titre, int Largeur, int Hauteur);
///////////////////////////////////////////////////////////////////////////////
// RemplirFenetre
// Colore toute la fenêtre d'une certaine couleur
// Intrant: Rouge: Composante rouge de la couleur (0-255)
//          Vert : Composante verte de la couleur (0-255)
//          Bleu : Composante bleue de la couleur (0-255)
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void RemplirFenetre(int Rouge, int Vert, int Bleu);
///////////////////////////////////////////////////////////////////////////////
// DessinerRectangle
// Permet de dessiner un rectangle d'une certaine couleur dans la fenêtre
// Intrant: PosX: Position horizontale du rectangle. 
//          PosY: Position verticale du rectangle. 
//          Le point (0,0) est en haut à gauche
//			Largeur: Largeur du rectangle en pixels
//			Hauteur: Hauteur du rectangle en pixels
//          Rouge: Composante rouge de la couleur (0-255)
//          Vert : Composante verte de la couleur (0-255)
//          Bleu : Composante bleue de la couleur (0-255)
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void DessinerRectangle(int PosX, int PosY, int Largeur, int Hauteur, int Rouge, int Vert, int Bleu);
///////////////////////////////////////////////////////////////////////////////
// ChargerImage
// Permet de charger une image du disque dur vers la mémoire
// Le seul type d'image supporté est le bitmap (BMP)
// Intrant: NomFichier: Nom du fichier image. Le fichier doit être dans le 
//                      même répertoire que le projet
// Extrant: un numéro identifiant uniquement l'image
///////////////////////////////////////////////////////////////////////////////
ImageId ChargerImage(string NomFichier);
///////////////////////////////////////////////////////////////////////////////
// AfficherImage
// Permet d'afficher une image à un certain endroit dans le fenêtre graphique
// Intrant: Image: Numéro de l'image
//			PosX: Position horizontale de l'image
//          PosY: Position verticale de l'image
//          Le point (0,0) est en haut à gauche
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void AfficherImage(ImageId Image, int PosX, int PosY);
///////////////////////////////////////////////////////////////////////////////
// RafraichirFenetre
// Mettre à jour la fenêtre d'affichage pour que les dernières modifications
// soient visibles
// Intrant: Aucun
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void RafraichirFenetre();
///////////////////////////////////////////////////////////////////////////////
// QuitterAffichage
// Ferme la fenêtre graphique
///////////////////////////////////////////////////////////////////////////////
void QuitterAffichage();
///////////////////////////////////////////////////////////////////////////////
// AttendreEvenement
// Attend que l'usager appuie sur une touche du clavier
// Intrant: Aucun
// Extrant: L'événement correspondant à la touche du clavier:
//   EVHaut: Flèche vers le haut
//   EVBas:  Flèche vers le bas
//   EVDroite: Flèche vers la droite
//   EVGauche: Flèche vers la gauche
//   EVQuitter: Esc
///////////////////////////////////////////////////////////////////////////////
Evenement AttendreEvenement(int& PosX, int& PosY, int MaxX, int MaxY);
 
void DeplacerHaut(int& PosX, int& PosY, int MaxX, int MaxY);
void DeplacerBas(int& PosX, int& PosY, int MaxX, int MaxY);
 
void DeplacerGauche(int& PosX, int& PosY, int MaxX, int MaxY);
void DeplacerDroite(int& PosX, int& PosY, int MaxX, int MaxY);
void Deux();
void Un();
void trois();
 
#endif //_SDLCLG_H

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
 
///////////////////////////////////////////////////////////////////////////////
// sdlclg.cpp
// Interface de programmation graphique pour le cours de KA0 utilisation la
// la libraire SDL 2.0.4-VC
// Joan-Sébastien Morales, Stéphane Chassé et Etienne Forest
// Version 1.0 Création 25 octobre 2009
// Version 1.1 Modification 27 octobre 2009
//   -- Ajout de messages d'erreurs
//   -- Ajout de la fonction RafraichirFenetre
// Version 1.2 Modification 17 novembre 2009
//   -- Ajout du type ImageId
//   -- Ajout de l'énumération Evenement
//   -- Ajout de la fonction AttendreEvenement
// Version 1.21 Modification 24 novembre 2009
//   -- Correction d'un bug avec la fonction AttendreEvenement
// Version 1.3 Modification 23 septembre 2016
//   -- Conversion à SDL 2.0.4 pour Visual Studio 2015
// Version 1.31 Modification 31 octobre 2016
//   -- Correction d'un problème de création de textures à l'affichage
//      qui remplissait la RAM inutilement
///////////////////////////////////////////////////////////////////////////////
 
// Finalement débarrassés de windows.h!
#include <vector> // Pour stocker les images
#include <iostream>
#include "sdlclg.h"
 
SDL_Window *fenetre = 0;  // On peut maintenant créer plusieurs fenêtres
						  // On doit donc en créer une avant de faire quoi que ce soit.
SDL_Renderer *renderer = 0; // On doit créer un renderer pour afficher des textures dans la fenêtre
vector<SDL_Surface*> Images;  // Vecteur d'images, inchangé en SDL2
vector<SDL_Texture*> Textures; // Vecteur de textures, nouveauté.  On affiche des textures construites à partir des images
	// Mais on doit conserver les images aussi pour accéder à leurs propriétés.
 
inline void VerifierErreur(bool Test, string Msg)
{
	if (Test)
	{
		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Erreur!", Msg.c_str(), NULL); // NULL : No parent window
		// MessageBox de SDL, plus besoin de windows.h
		exit(1);
	}
}
 
void Attendre(int Temps)
{
	VerifierErreur(Temps <= 0, "Attendre: Temps invalide");
	SDL_Delay(Temps); // Maintenant inclus dans SDL, plus besoin de windows.h!
}
 
void InitialiserAffichage(string Titre, int Largeur, int Hauteur)
{
	VerifierErreur(Largeur <= 0, "InitialiserAffichage: Largeur invalide");
	VerifierErreur(Hauteur <= 0, "InitialiserAffichage: Hauteur invalide");
 
	SDL_Init(SDL_INIT_VIDEO);
	SDL_CreateWindowAndRenderer(Largeur, // La fonction a changé un peu en SDL2 à cause de la fenêtre et du renderer
			Hauteur,
			SDL_WINDOW_RESIZABLE,
			&fenetre,
			&renderer);
	VerifierErreur(!fenetre, "InitialiserAffichage: Impossible de charger le mode vidéo");
	VerifierErreur(!renderer, "InitialiserAffichage: Impossible de créer le rendu");
	SDL_SetWindowTitle(fenetre, Titre.c_str()); // Changé en SDL2
}
 
void RemplirFenetre(int Rouge, int Vert, int Bleu)
{
	VerifierErreur(Rouge<0 || Rouge>255, "RemplirFenetre: Couleur rouge invalide");
	VerifierErreur(Vert<0 || Vert>255, "RemplirFenetre: Couleur verte invalide");
	VerifierErreur(Bleu<0 || Bleu>255, "RemplirFenetre: Couleur bleue invalide");
 
	SDL_SetRenderDrawColor(renderer, Rouge, Vert, Bleu, 255); // Alpha 255: opaque	
	SDL_RenderClear(renderer); // RenderClear "vide" le renderer avec la couleur choisie
}
 
void DessinerRectangle(int PosX, int PosY, int Largeur, int Hauteur,
	int Rouge, int Vert, int Bleu)
{
	VerifierErreur(PosX<0, "DessinerRectangle: PosX invalide");
	VerifierErreur(PosY<0, "DessinerRectangle: PosY invalide");
	VerifierErreur(Largeur<0, "DessinerRectangle: Largeur invalide");
	VerifierErreur(Hauteur<0, "DessinerRectangle: Hauteur invalide");
	VerifierErreur(Rouge<0 || Rouge>255, "DessinerRectangle: Couleur rouge invalide");
	VerifierErreur(Vert<0 || Vert>255, "DessinerRectangle: Couleur verte invalide");
	VerifierErreur(Bleu<0 || Bleu>255, "DessinerRectangle: Couleur bleue invalide");
 
	SDL_Surface *rectangle = 0;
	SDL_Texture* rectTexture = 0; 
	SDL_Rect destR;
 
	// Créer la surface
	rectangle = SDL_CreateRGBSurface(0, Largeur, Hauteur, 32, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff); // masques RGBA
	// Remplir avec la couleur
	SDL_FillRect(rectangle, NULL, SDL_MapRGB(rectangle->format, Rouge, Vert, Bleu));
	// Créer la texture à partir de la surface (nouveau de SDL2)
	rectTexture = SDL_CreateTextureFromSurface(renderer, rectangle);
	SDL_FreeSurface(rectangle); // Libération de la surface
 
	// Destination dans la fenêtre
	destR.x = PosX;
	destR.y = PosY;
	destR.h = Hauteur;
	destR.w = Largeur;
 
	// Copier la texture rectangle dans le renderer
	SDL_RenderCopy(renderer, rectTexture, NULL, &destR); // NULL: Copier la texture au complet 
}
 
ImageId ChargerImage(string NomFichier)
{
	SDL_Surface* Image = SDL_LoadBMP(NomFichier.c_str());
 
	VerifierErreur(!Image, string("ChargerImage: Impossible de charger l'image ") + NomFichier);
 
	Images.push_back(Image);
 
	// Le color key doit être set ici, dans l'image.  Problème si on le fait plusieurs fois (à l'affichage)
	SDL_SetColorKey(Images[Images.size()-1], SDL_TRUE, // enable color key (transparency)
		SDL_MapRGB(Images[Images.size()-1]->format, 0, 0, 0));
 
	// Créer une texture à partir de la surface (image)
	SDL_Texture* Texture = SDL_CreateTextureFromSurface(renderer, Images[Images.size()-1]);
	Textures.push_back(Texture);
 
	return Images.size() - 1;
}
 
void AfficherImage(ImageId Image, int PosX, int PosY)
{
	VerifierErreur(Image<0 || unsigned int(Image)>Images.size() - 1, "Numéro d'image invalide");
	VerifierErreur(PosX<0, "AfficherImage: PosX invalide");
	VerifierErreur(PosY<0, "AfficherImage: PosY invalide");
 
	// Rectangle représentant la position et la dimension de l'image dans la fenêtre
	SDL_Rect position;
	position.x = PosX;
	position.y = PosY;
	position.h = Images[Image]->h; // SDL2
	position.w = Images[Image]->w; // SDL2
 
	// Copier la texture dans le renderer
	SDL_RenderCopy(renderer, Textures[Image], NULL, &position); // NULL: Copier la texture au complet 
}
 
void RafraichirFenetre()
{
	SDL_RenderPresent(renderer);  // SDL2
}
 
void QuitterAffichage()
{
	// Libérer les surfaces (images)
	for (unsigned int i = 0; i<Images.size(); i++)
	{
		SDL_FreeSurface(Images[i]);
	}
	// Détruire le renderer
	SDL_DestroyRenderer(renderer);
	// Détruire la fenêtre
	SDL_DestroyWindow(fenetre);
	// Quitter
	SDL_Quit();
}
 
Evenement AttendreEvenement(int& PosX, int& PosY, int MaxX, int MaxY)
{
	// Rien n'a changé ici avec SDL2
	Evenement e = EVAucun;
	SDL_Event event;
	bool Valide = false;
	while (!Valide)
	{
		SDL_WaitEvent(&event);
		switch (event.type)
		{
		case SDL_QUIT:
			e = EVQuitter;
			Valide = true;
			break;
		case SDL_KEYDOWN:
			switch (event.key.keysym.sym)
			{
			case SDLK_UP: // Flèche haut
				e = EVHaut;
				Valide = true;
				DeplacerHaut(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_DOWN: // Flèche bas
				e = EVBas;
				Valide = true;
				DeplacerBas(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_RIGHT: // Flèche droite
				e = EVDroite;
				Valide = true;
				DeplacerGauche(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_LEFT: // Flèche gauche
				e = EVGauche;
				Valide = true;
				DeplacerDroite(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_ESCAPE: /* Appui sur la touche Echap, on arrête le programme */
				e = EVQuitter;
				Valide = true;
				break;
			}
			break;
		}
	}
	return e;
}

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
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
#include "sdlclg.h"
#include <iostream>
#include <Windows.h>
#include <mmsystem.h>
using namespace std;
int main(int argc, char *argv[])
{
	PlaySound(TEXT("musique.wav"), NULL, SND_FILENAME | SND_NODEFAULT | SND_ASYNC);
	bool win = false;
	bool Arret = false;
	InitialiserAffichage("Jeu", 800, 600);
	ChargerImage("fond.bmp");
	ChargerImage("sapin.bmp");
	ChargerImage("bonhomme.bmp");
	ChargerImage("cadeau.bmp");
	ChargerImage("traineau.bmp");
	ChargerImage("win.bmp");
	ChargerImage("petitflocon.bmp");
	ChargerImage("loading.bmp");
	AfficherImage(7, 0, 0);
	RafraichirFenetre();
	srand(static_cast<unsigned int>(time(0)));
	Objet Tableau[NbCases][NbCases];
	Position Bonhomme;
	Bonhomme.x = rand() % NbCasesX;
	Bonhomme.y = rand() % NbCases;
	const int NombreFlocon = 50;
	Position Flocons[NombreFlocon];
	for (int i = 0; i <= NombreFlocon-1; i++) {
		Flocons[i] = {
		rand() % NbCasesX,
		rand() % NbCases
		};
		Tableau[Flocons[i].x][Flocons[i].y] = Flocon;
	}
	AfficherImage(0, 0, 0);
	AfficherImage(1, 670, 220);
	AfficherImage(3, 550, 450);
	AfficherImage(4, 430, 40);
	sleep_for(seconds(2));
	RafraichirFenetre();
	while (!win) {
		AfficherImage(0, 0, 0);
		AfficherImage(1, 670, 220);
		AfficherImage(3, 550, 450);
		AfficherImage(4, 430, 40);
		system("cls");
		for (int i = 0; i <= NombreFlocon - 1; i++) {
				if (Tableau[Flocons[i].x][Flocons[i].y] == Vide) {
				}
				else if (Tableau[Flocons[i].x][Flocons[i].y] == Flocon) {
					AfficherImage(6, Flocons[i].x*NbPixelsParCase, Flocons[i].y*NbPixelsParCase);
					//cout << "Flocon #" << i << " " << Flocons[i].x << " " << Flocons[i].y << endl; //Deboguage
				}
		}
		AfficherImage(2, Bonhomme.x*NbPixelsParCase, Bonhomme.y*NbPixelsParCase);
		//cout << "Position actuelle: " << Bonhomme.x << " " << Bonhomme.y << endl; //Deboguage
		RafraichirFenetre();
 
		AttendreEvenement(Bonhomme.x, Bonhomme.y, Arret);
		if (Arret) {
			QuitterAffichage();
			return 0;
		}
		if (Bonhomme.x >= 23) {
			Bonhomme.x = 23;
		}
		if (Bonhomme.x <= 0) {
			Bonhomme.x = 0;
		}
		if (Bonhomme.y >= 16) {
			Bonhomme.y = 16;
		}
		if (Bonhomme.y <= 0) {
			Bonhomme.y = 0;
		}
		for (int i = 0; i <= NombreFlocon - 1; i++) {
			if ((Bonhomme.x <= Flocons[i].x && Bonhomme.x +1 >= Flocons[i].x) && (Bonhomme.y <= Flocons[i].y && Bonhomme.y+2 >= Flocons[i].y)) {
					Tableau[Flocons[i].x][Flocons[i].y] = Vide;
				}
				else {
				}
		}
		win = true;
		for (int i = 0; i <= NombreFlocon - 1; i++) {
			if (Tableau[Flocons[i].x][Flocons[i].y] == Flocon) {
				win = false;
			}
			else {
 
			}
		}
	}
	if (win) {
		ChargerImage("win.bmp");
		AfficherImage(8, 0, 0);
		RafraichirFenetre();
		sleep_for(seconds(5));
		QuitterAffichage();
	}
		return 0;
}
 
void Chargement() {	
	InitialiserAffichage("Hunt", 800,600);
}
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Merci énormément

22/10/2017, 10h19
LittleWhite

Bonjour,

Sachant que vous n'avez pas donner l'intégralité du code, notamment le code des fonctions concernées, il n'est pas possible de deviner ce qui se passe mal.
De plus, vous pouvez trouver vous même ce qui se passe mal en utilisant le débogueur. Vous avez une corruption de la mémoire, maintenant il faut comprendre/trouver où.
23/10/2017, 03h19
felix104116

Bonjour,

Désolé pour cela, je viens d'include le header et l'autre cpp.

Merci

Heu, franchement, votre code, c'est 95% de C (assez mauvais) et 5% de très mauvais C++.

Faudrait choisir, c'est du C ou du C++ ???

Déjà, SDL, c'est une librairie C, pas C++.
Si vous voulez vous en servir correctement en C++, il faut que vous fassiez un wrapper C++ autour.
Parce qu'en C, c'est des valeurs de retour pour les codes d'erreurs (ce que vous ne vérifiez quasiment jamais => mauvais C), en C++, c'est des exceptions.

Citation:

Petites précision: Le jeu marche

Avec une erreur pareil ?
Le jeu, il ne fonctionne pas, il est sauvé in extremis par le runtime Debug qui évite la catastrophe direct.
Ce message d'erreur, c'est juste le runtime Debug qui à mis des zones mémoires de "sécurité" entre chaque variable (des canaris) et il c'est rendu compte que quelqu'un avait écrit dans ces zones où personne de devrait écrire.
En clair, en vrai, votre programme ne fonctionne pas et plantera aléatoirement, et généralement au pire moment.

Citation:

(il exécute un fichier .h et un fichier de prototypes .cpp)

.h ne s’exécute pas, c'est la base du C, et du C++.

Comme votre code est bourré d'erreur, il serait plus simple de les corriger plutôt que de savoir laquelle a salopé la mémoire.

- cartouche de gestion de version ???
Vous utilisez pas un gestionnaire de code source comme GetHub ou Subversion ?
Vous êtes complètement marteau ???

- pas de using dans les .h, jamais.

- préférez using à typedef
http://en.cppreference.com/w/cpp/language/type_alias

- codez en Anglais
Citation:
Code:

1 2 3 4 5 6 7 /////////////////////////////////////////////////////////////////////////////// // Attendre // Permet de placer le programme en attente pendant un certain temps // Intrant: Temps: Nombre de millisecondes // Extrant: Aucun /////////////////////////////////////////////////////////////////////////////// void Attendre(int Temps);
- Commentaires qui se substitue à un nommage correcte des méthodes, des arguments, etc...
Utilisez correctement les noms.
Code:

1 2 void Wait(int delayInMilliseconde);
Citation:
Code:

1 2 3 void Deux(); void Un(); void trois();
WTF ?

Citation:

Code:

Evenement AttendreEvenement(int& PosX, int& PosY, int MaxX, int MaxY);

Pourquoi des passages de paramètre int par référence vu qu'ils n'ont pas à être modifier dans ces fonctions ?

Citation:

Code:

inline void VerifierErreur(bool Test, string Msg)

Inline ?, c'est que dans les .h.

En plus c'est pas "VerifierErreur" qu'elle fait mais "Assert", nommez correctement vos fonctions, SVP.
En plus le "exit" et l'appel à une librairie graphique pour ce genre de truc, c'est nimpornawak.
Utilisez plutôt l'instruction "assert" : http://en.cppreference.com/w/cpp/error/assert

Passage d'un chaine de caractère par copie et pas références constantes ???
Citation:
Code:

1 2 3 4 5 6 void RemplirFenetre(int Rouge, int Vert, int Bleu) { VerifierErreur(Rouge<0 || Rouge>255, "RemplirFenetre: Couleur rouge invalide"); VerifierErreur(Vert<0 || Vert>255, "RemplirFenetre: Couleur verte invalide"); VerifierErreur(Bleu<0 || Bleu>255, "RemplirFenetre: Couleur bleue invalide"); ...
Utilisez des type de paramètre adapté "uint8_t": http://en.cppreference.com/w/cpp/types/integer
Citation:
Code:

1 2 3 4 5 6 SDL_Window *fenetre = 0; // On peut maintenant créer plusieurs fenêtres // On doit donc en créer une avant de faire quoi que ce soit. SDL_Renderer *renderer = 0; // On doit créer un renderer pour afficher des textures dans la fenêtre vector<SDL_Surface*> Images; // Vecteur d'images, inchangé en SDL2 vector<SDL_Texture*> Textures; // Vecteur de textures, nouveauté. On affiche des textures construites à partir des images // Mais on doit conserver les images aussi pour accéder à leurs propriétés.
Les variables globales, c'est caca, virez-moi ces cochonneries.

Usage de pointeurs nus avec aucune indications de comment et gérer les cycles de vies de ce qu'ils références : utilisez des pointeurs intelligents, SVP.

Citation:

Code:

system("cls");

Vous me dégagez ça fissa.

Citation:

Code:

srand(static_cast<unsigned int>(time(0)));

srand/rand, c'est du C, pas du C++:
http://en.cppreference.com/w/cpp/numeric/random

Citation:

Code:

Position Flocons[NombreFlocon];

On me dégage ces tableaux C, en C++, c'est std::array.

Citation:

Code:

AttendreEvenement(Bonhomme.x, Bonhomme.y, Arret);

C'est même pas conforme à la déclaration dans le .h => ça ne devrait même pas compiler.
Vous l'avez configurer comment votre compilateur pour qu'il ne vous envoie pas bouler comme il devrait ?

et c'est sans compter avec le mélange peu digeste du code graphique avec le reste de code.

etc...

23/10/2017, 21h44
felix104116

Bonjour!

Merci énormément de votre réponse.

Citation:

Envoyé par bacelar

Heu, franchement, votre code, c'est 95% de C (assez mauvais) et 5% de très mauvais C++.
Déjà, SDL, c'est une librairie C, pas C++.
Si vous voulez vous en servir correctement en C++, il faut que vous fassiez un wrapper C++ autour.
Parce qu'en C, c'est des valeurs de retour pour les codes d'erreurs (ce que vous ne vérifiez quasiment jamais => mauvais C), en C++, c'est des exceptions.

Je tiens à préciser que toutes les fonctions qui sont précédées de commentaires ont été faites par mon enseignant.
On nous introduit à l'utilisation d'interface à avec SDL je suppose alors je n'ai pas décidé de me servir de ce module...
Je ne suis pas encore très avancé en C++.

Citation:

Envoyé par bacelar

Avec une erreur pareil ?
Le jeu, il ne fonctionne pas, il est sauvé in extremis par le runtime Debug qui évite la catastrophe direct.
Ce message d'erreur, c'est juste le runtime Debug qui à mis des zones mémoires de "sécurité" entre chaque variable (des canaris) et il c'est rendu compte que quelqu'un avait écrit dans ces zones où personne de devrait écrire.
En clair, en vrai, votre programme ne fonctionne pas et plantera aléatoirement, et généralement au pire moment.

Que voulez-vous dire par le fait qu'il est sauvé par le runtime Debug? Comment pourrais-je régler cela et comment pourrais-je améliorer mon code?

Sinon je vais prendre note de ce que vous m'avez dit, coder en anglais.
Inline ?, c'est que dans les .h.

Citation:

Envoyé par bacelar

Les variables globales, c'est caca, virez-moi ces cochonneries.

Encore une fois, variables données par mon enseignant.

Citation:

Envoyé par bacelar

Usage de pointeurs nus avec aucune indications de comment et gérer les cycles de vies de ce qu'ils références : utilisez des pointeurs intelligents, SVP.

Comment se servir de pointeurs intelligents??

Citation:

Envoyé par bacelar

On me dégage ces tableaux C, en C++, c'est std::array.

Ce ne serait pas plus des std::vector?

Citation:

Envoyé par bacelar

et c'est sans compter avec le mélange peu digeste du code graphique avec le reste de code.

etc...

Les fonctions void un(); void deux(); et void trois();
sont des exercices différents, je n'aurais juste pas dû les inclure dans ce code.

De plus la raison pour laquelle mon compileur accepte la fonction AttendreEvenement() est que j'ai modifié les paramètres de la fonction AttendreEvenement().

Désolé pour ce mal de coeur haha :p

Merci encore!
24/10/2017, 09h32
Kannagi

Citation:

Envoyé par felix104116

Encore une fois, variables données par mon enseignant.

si c'est le cas c'est un mauvais prof !
Un prof qui donne comme exemple un code en variable global voila quoi...
Moi mon prof me les interdisait complètement et ça aurait du être votre cas aussi !

Le souci est aussi que l'architecture est mal pensé (oui oui ton prof) , mais je tiens quand meme a le souligner , le but d'une fonction reste (en C) d'éviter les effets de bord ce qu'aucune des fonctions respectes !
Un autre point qui me gêne , dans un jeux vidéo on évite de mettre du code dans les events (récupération des touche clavier/souris/joypad etc ) , normalement on récupère si la touche est appuyé (0 ou 1 avec une variable , tableau etc ) , on soit ça évite que le code soit un gros bordel et impossible a maintenir !
24/10/2017, 14h44
bacelar

OK, alors je sais pas ce que cherche à vous enseigner votre prof., mais c'est surement pas la bonne manière de coder, ni en C, ni en C++.

Et si c'est l'algorithmie, je trouve que c'est un exemple bien trop "complexe" pour ce genre d'apprentissage.

Franchement, ça fait cours "Education National" (mention spéciale "Toubon" ministre de 1995 à 1997) pour le français "à l'ouest", écrit par une personne qui a de vague lumière en C (du void partout et traitement des erreurs à coup d'exit, c'est vraiment laid, même pour du vieux C, et les variables globales, c'est du nimpornawak) et qui croit que le C++ n'est qu'une vague extension anecdotique du C.

Clairement, je ne sais pas comment on peut vous aider, parce que là, ce code est complètement bon à jeter à la poubelle car im-maintenable.

Citation:

On nous introduit à l'utilisation d'interface à avec SDL je suppose alors je n'ai pas décidé de me servir de ce module...

Alors, faites du C, pas du C++.
Et faites du C correctement, donc pas de variables globales, traitement SYSTÉMATIQUE des codes retours, pas d'exit, etc...
Beaucoup de mes remarques sont aussi valide pour du C.

Citation:

Je ne suis pas encore très avancé en C++.

Normalement, après l'algorithmie, on apprend les classes en C++, et ici, pas une trace de ce concept qui simplifierait largement ce code.

Citation:

Que voulez-vous dire par le fait qu'il est sauvé par le runtime Debug?

Quand vous compilez en Debug, l'implémentation des primitives C, comme "malloc", "free" ect... font du travail supplémentaire pour détecter des mauvaises manières de faire.
Un cas fréquent de problème en C, c'est de modifier les valeurs de variables qui n'ont rien demandé, comme une variable juste derrière une autre variable de type tableau et qu'on se plante dans le calcul des bornes du tableau et donc qu'on écrase la variable derrière en croyant modifier que les données dans le tableau.
La C-Runtime en Debug va donc séparer les différentes variables par une zone mémoire remplie avec un pattern particulier (les canaris), qui permet d'avoir des chances de détecter des écritures foireuses en mémoire.
S'il n'y avait pas les canaris, donc en Release par exemple, l'écriture foireuse aurait très probablement écrabouillé la valeur contenue dans une autre variable.
Donc, oui le runtime Debug a "sauvé" votre programme mais vous devez déterminer quel partie du code à saloper la mémoire.

Citation:

Comment pourrais-je régler cela et comment pourrais-je améliorer mon code?

Pour cela, je vous conseille chaudement d'utiliser les bonnes pratiques du C ou du C++ qui reduise drastiquement les possibilités de faire ce type de connerie (écriture dans une zone mémoire qui n'est pas la bonne).
Il reste aussi le débogueur qui permet de voir quelle instruction modifie une case mémoire avec un type de point d'arrêt approprié.

Citation:

Sinon je vais prendre note de ce que vous m'avez dit, coder en anglais.
Inline ?, c'est que dans les .h.

Tout le reste est très important aussi.

Citation:

Encore une fois, variables données par mon enseignant.

Faites lui remarquer gentiment que c'est une très mauvaise pratique.
Il y a des cas où on n'a pas le choix, mais ici, c'est clairement de la "fainéantise".

Citation:

Comment se servir de pointeurs intelligents??

http://fr.cppreference.com/w/cpp/memory/unique_ptr
http://fr.cppreference.com/w/cpp/memory/shared_ptr

Citation:

Ce ne serait pas plus des std::vector?

Si votre tableau est de taille variable.
Ici, il est de taille fixe, donc std::array, mais utilisez un std::vector ici n'est pas gênant. Qui peut le plus, peut le moins.

Citation:

Désolé pour ce mal de coeur haha :p

Le plus important, c'est que vous gardiez courage pour progresser, c'est jamais simple. ;)
24/10/2017, 16h06
felix104116

Merci encore pour ces réponses qui m'ont grandement éclairci. J'ai toutefois quelques questions qui me restent en tête...

Mon projet Visual Studio est en C++ et donc les variables et le type d'écriture est C++, comment est-ce possible que mon code soit du C?
De plus, pouvez-vous m'expliquer qu'est-ce qui distingue le C++ du C?

Effectivement, dans notre exercice mon enseignant précise que le return 0; est important, j'avais déduit qu'il s'agissait de C et non de C++ mais j'avais pris pour acquis que c'était nécessaire à la bibliothèque SDL.

Nous sommes toujours dans notre Cours d'Algorithmie et Introduction à la Programmation, nous avons appris tout ce qui touche aux for, while, do. Le reste de ma classe n'a pas poussé ses recherches mais je me suis aventuré plus loin et j'ai appris les classes. Mais il est difficile pour moi d'intégrer des connaissances de Classes dans un projet plus ou moins clair comme le jeu. Sachant que je ne savais pas trop comment m'y prendre, je ne me suis pas servi de classes, alors j'ai tout lancé dans le main avec quelques exceptions.

Merci!

Citation:

Mon projet Visual Studio est en C++ et donc les variables et le type d'écriture est C++, comment est-ce possible que mon code soit du C?

Visual Studio est un IDE multi-language.
On peut faire du VB.NET, du Javascript, du COBOL, du R, du C, du C++, du C#, du F# etc... dans cet IDE.
Il y a même des types de projets qui permettent de mélanger plusieurs langages (Les projet Web avec du TypeScript et un langage .NET par exemple, etc...)

En sélectionnant un type de projet C++ dans la liste des modèles de projet, vous n'avez que sélectionné un ensemble d'outils qui seront utilisés pour passer d'un ensemble de fichiers sources à un exécutable, avec tout une collection de réglage par défaut de ces outils. On appel cela une "chaine de compilation" (préprocesseur -> compilateur (avec plein de sous-étapes) -> éditeur de lien).

Il est même possible de créer ces propres modèles de projet qui utiliseront les outils de votre cru, si vous voulez.

Par défaut, les projets C++ sont configurés pour utiliser un (préprocesseur + compilateur) nommé CL.EXE et un éditeur de lien nommé LINK.EXE. On appelle cette paire (avec plein d'autres outils plus spécifique) MSVC++ ou MSVC, pour MicroSoft Visual C++.
Il est possible de configurer Visual Studio pour utiliser une autre chaine de compilation C++, comme Clang (qui est officiellement supporté depuis VS2017), pour les autres chaines de compilations comme GCC, MinGW etc.., c'est bien plus complexe à mettre en place.

Ce n'est donc pas Visual Studio qui indique le langage, mais c'est la chaine de compilation qui comprendra le contenu des fichiers sources, ou pas.

Il est donc possible de faire un code "malin" qui soit compris à la fois par une chaine de compilation C et aussi par une chaine de compilation C++. Mais ce code ne sera bien écrit ni en C ni en C++ car les manières de "bien" programmer sont très différentes entre les langages.

Vous pouvez donc programmer en C dans Visual Studio, si vous configurez les propriétés du projet pour utiliser une chaine de compilation C.

MSVC++ est une chaine de compilation C++, qui tente de suivre l'ensemble des normes C++ (C++11, C++14, C++17 et celle avenir C++20).
Mais les mecs de Microsoft savent très bien qu'il existe un ensemble de dinosaures qui persistent à faire du C sous Windows, et donc, il existe des options de compilation pour demander à la chaine de compilation MSVC++, de prendre en compte le fait que le fichier "x.c" ou "y.c" est en C et qu'il devrait faire comme s'il était un compilateur C et pas C++ pour ces fichiers.
Pire, l'interface de plus bas niveau de Windows est une API C, c'est à dire que les autres langages souhaitant utiliser ces API (créer une fenêtre, créer une console) doivent le faire "comme si" ils étaient du C.
Comme le C++ permet, via des circonvolutions type 'Extern "C" {...}', de faire du "C" dans du C++ (en faite, exporter le code généré comme si il était écrit en C), il est possible d'attaquer directement ces API bas niveau en C++.
Mais ce type de C++ est un mélange de langages qu'il ne faut pas faire sans un peu de bagage derrière soi.
De plus, les concepteurs de MSVC++ essaye donc de faire un compilateur C++ "moderne" mais qui puisse encaisser les vieilleries C. Mais ce n'est pas un vrai compilateur C, supportant les dernières norme du C (C90, C99, ...). Le support de ces dernières normes C sont très parcellaire. Et quand le support d'une norme C induit une incompatibilité avec le C++, c'est le C++ qui prime (exemple, le VLA de la norme C90 qui n'est pas supporté par MSVC++).

Citation:

De plus, pouvez-vous m'expliquer qu'est-ce qui distingue le C++ du C?

Énormément de choses.
Je ne fais plus de C depuis près de 25 ans mais, par exemple les VLA ne sont supporté que par le C (https://en.wikipedia.org/wiki/Variable-length_array).
En C++, les classes, les exceptions, les templates, les lambda expressions, le concept de RAII, les pointeurs intelligents, les namespaces etc...

Des choses sont encore plus piégeuses car elles sont différentes entre les langages malgré l'utilisation de mos-clé identiques, comme "struct".

Citation:

Effectivement, dans notre exercice mon enseignant précise que le return 0; est important,

C'est important en C. En C++ on utilise des exceptions pour faire remonter les erreurs et l'éventuelle valeur retournée correspond au résultat attendu de la fonction, jamais un cas d'erreur.

Citation:

j'avais déduit qu'il s'agissait de C et non de C++ mais j'avais pris pour acquis que c'était nécessaire à la bibliothèque SDL.

Et c'est le cas, SDL est une librairie C, pas C++.
Elle se comporte comme des fonctions C, et pas comme des fonctions C++.
Il faut donc vérifier les valeurs de retour, comme en C, même si on code en C++.
C'est pour cela que je vous avez conseiller de ne pas utiliser ce type de librairie mais d'utiliser des librairies C++ qui, elles, respectent la manière de faire en C++ (exception, etc...).

Citation:

Nous sommes toujours dans notre Cours d'Algorithmie et Introduction à la Programmation,

Vous ne devriez donc pas toucher à des trucs comme la SDL.

Citation:

et j'ai appris les classes

Pourquoi ne pas les utiliser alors ?
On peut facilement supprimer ces horribles variables globales avec quelques champs dans une classe.

Citation:

Mais il est difficile pour moi d'intégrer des connaissances de Classes

Un cas "simple", faites une classe qui cache tout ce qui est affichage et que votre main ressemble à ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include "sdlclg.h" #include <Windows.h> #include "MyGui.h" #include "Bonhomme.h" #include "Grille.h" int main(int argc, char *argv[]) { PlaySound(TEXT("musique.wav"), NULL, SND_FILENAME | SND_NODEFAULT | SND_ASYNC); Bonhomme bonhomme{rand() % NbCasesX, rand() % NbCasesY}; Grille grille{NbCasesX, NbCasesY, NombreFlocon}; MyGui gui{"Jeu", 800, 600, bonhomme, grille}; while (!gui.Process()) { grille.Manger(bonhomme); } return 0; }

25/10/2017, 02h31
felix104116

D'accord!

Mais étant donné que l'exercice est avec SDL, je dois donc me servir de ce module? Alors il ne me reste qu'à utiliser des classes et paufiner le code?
Merci énormément pour l'aide, ça vient de m'éclaircir énormément.

Je ne comprends toutefois pas les pointeurs ainsi que les pointeurs intelligents, on m'a expliqué qu'un pointeur pointe l'adresse de mémoire d'un élément mais je ne comprends
pas quand m'en servir et à quoi ça sert en général...
25/10/2017, 08h07
Christophe

Il est possible de mélanger du C et du C++, correctement programmé ça fonctionne, mais ça n'a pas de sens. Tu vas perdre les avantages du C++ par rapport au C et avoir du code beaucoup plu illisible et déboguable.

C++ utilise ses propres headers pour les fonctions standard.

Pour répondre à ta dernière question : un pointeur, c'est une variable qui va contenir une adresse mémoire d'une autre variable. Il est généralement typé mais peut être aussi de type void. Exemple une chaine en C (exemple char chaine[10]; ) est un tableau de char. Il peut aussi être considéré et utilisé comme un pointeur pointant sur le premier élément du tableau. En C++, tu va utiliser un array. L’avantage de celui-ci par rapport à un tableau de char en C est la possibilité d'appliquer des méthodes dessus telles que array.end(), array.size(), etc. tu gères donc ton tableau comme un objet avec ces propriétés (variables internes à l'objet) et ces méthodes (fonctions interne à l'objet).

Pour revenir au pointeurs, il te faut gérer l'allocation mémoire avec malloc et sa libération avec free. Un pointeur intelligent te simplifie cette tache, et va donc aussi éviter les erreurs d’écrasement de variables tel que tu rencontres. Mais ce n'est disponible qu'en C++. Quand tu instancie un objet en C++ avec new (déclare un objet prédéfini), la réservation de la mémoire ce fait automatiquement, tu n'as pas à t'en préoccuper. Quand tu détruit l'objet avec delete, la mémoire réservée est automatiquement libéré. Cela évite beaucoup de fuites mémoires et pointeurs non initialisés.

Le C++ te donne accès à plein de choses beaucoup plus difficiles à faire en C.
25/10/2017, 08h37
Kannagi

Citation:

Envoyé par felix104116

Je ne comprends toutefois pas les pointeurs

Pourtant en C c'est complètement indispensable , et je trouve cela étrange que le prof vous demande d'utiliser la SDL ,si les élèves ne maîtrise pas les pointeurs (impossible d'utiliser correctement la SDL si on ne maîtrise pas les pointeurs).