Discussion :

[Ulhana]

Bonjour,
J'espère que je suis au bon endroit pour ma question...

Je suis étudiante en DUT informatique et nous avons comme projet de programmer un puissance 4 en C sur visual studio.
Pour l'instant mon projet ne ressemble pas à grand chose et j'avoue être bloquée au tout début du code.
Mon projet est séparé en 3 fichiers :
- Un ficher .h où sont déclarées mes fonctions
- Un fichier .cpp où sont définies mes fonctions
- Un fichier main.cpp

Ce que fait mon programme :
Après avoir demandé le prénom du joueur 1 et du joueur 2, il affiche :
"Choissisez une colonne parmi : a, b, c, d, e, f, g :
Erreur de saisie, saisissez une autre colonne :"
Donc il ne me laisse pas écrire le caractère de ma colonne dans un premier temps et je n'arrive pas à comprendre pourquoi...
Aussi, même si dans un second temps j'écris le caractère de ma colonne (entre a et g) il m'affiche encore "Erreur de saisie, saisissez une autre colonne :" deux fois de suite.

Est-ce que quelqu'un pourrait peut-être m'aider à comprendre pourquoi je rencontre ces problèmes ?
Si le code n'est pas agréable à lire tout en noir comme ça je peux peut-être envoyer une capture d'écran... je sais pas.

Précision : nous avons pour consigne d'utiliser une chaîne de caractère que nous utilisons comme un tableau.
Merci beaucoup!

Voici le code du fichier .cpp où sont définies mes fonctions et où je rencontre des erreurs.

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
174
175
176
177
178
179
 
//T2d.cpp
#define _CRT_SECURE_NO_WARNINGS
#include <assert.h>
#include <malloc.h>
#include <stdio.h>
#include "T2d.h"
 
 
 
void init(T2d* t, unsigned int largeur, unsigned int hauteur) {
	t->hauteur = hauteur;
	t->largeur = largeur;
	t->grille = (char*)malloc(largeur * hauteur);
	assert(t->grille != NULL);
	for (unsigned int i = 0; i < largeur * hauteur; ++i)
		t->grille[i] = '.';
 
}
 
unsigned int getLargeur(const T2d* t) {
	return t->largeur;
}
 
unsigned int getHauteur(const T2d* t) {
	return t->hauteur;
}
 
bool colPleine(T2d* t, char col) {
	unsigned int i = getHauteur(t);
	if (t->grille[i * t->largeur + (col - 'a')] != '.')
		return true;
	return false;
}
 
char getSymboles(unsigned int i) {
	assert(i < 3);
 
	// le tableau est initialisé au premier appel, il n'est pas détruit en sortant de la fonction.
	// il est stocké avec les variables globales avant le main
	static const char symboles[3] = { '.', 'X', 'O' };
 
	return symboles[i];
}
 
void set(T2d* t, char col, unsigned int ligne, char symbole) {
	t->grille[(ligne - 1) * t->largeur + (col - 'a')] = symbole;
}
 
char get(const T2d* t, char col, unsigned int ligne) {
	return t->grille[(ligne - 1) * t->largeur + (col - 'a')];
}
 
void liberer(T2d* t) {
	free(t->grille);
}
 
 
void toString(const T2d* t, char* s) {
	*s = 0;
	unsigned int d = 0;
 
	//afficher le tableau
	for (unsigned int ligne = getHauteur(t); ligne >= 1; --ligne) { // on affiche ligne par ligne
		d += sprintf(s + d, "%i ", ligne);
		for (char col = 'a'; col <= 'g'; ++col) // pour chaque ligne on affiche colonne par colonne de gauche à droite
			d += sprintf(s + d, "%c ", get(t, col, ligne));
		d += sprintf(s + d, "\n");
		//puts(""); //printf simplifié qui passe à la ligne
	}
 
	//afficher les colonnes
	d += sprintf(s + d, "  ");
	for (char col = 'a'; col <= 'g'; ++col)
		d += sprintf(s + d, "%c ", col);
	d += sprintf(s + d, "\n");
}
 
 
//Début du jeu
void debutJeu() {
	printf("Bonjour, bienvenue sur puissance 4! \n");
	printf("Joueur 1, entrez votre nom : ");
	scanf("%s");
	printf("Joueur 2, entrez votre nom : ");
	scanf("%s");
}
 
void jouer(T2d* t, unsigned int j) {
	char numCol;
 
	printf("Choissisez une colonne parmi : a, b, c, d, e, f, g :\n");
	scanf("%c", numCol);
	//tant que la colonne n'est pas valide, on demande à saisir une nouvelle colonne
	while (numCol < 'a' || numCol > 'g' || (colPleine(t, numCol))) {
		printf("Erreur de saisie, saisissez une autre colonne :\n");
		scanf("%c", numCol);
	}
 
	unsigned int i = getHauteur(t);
	int ligne;
	while (i = t->grille[(i - 1) * t->largeur + (numCol - 'a')] == '.') {
		--i;
	}
	ligne = i;
 
	//Définir les pions selon le joueur correspondant
	if (j == 0) {
		set(t, numCol, ligne, 'X');
	}
	else {
		set(t, numCol, ligne, 'O');
	}
 
}
 
//vérifier l'alignement horizontal
bool alignH(T2d* t, char col, unsigned int ligne, char* s) { // vérifie l'alignement horizontal
	unsigned int i = t->grille[(ligne - 1) * t->largeur + (col - 'a')];
	unsigned int c = 0;//compte le nbe de symboles identiques successifs
	unsigned int k = 1; // k ne compte pas le 0 du tab donc démarre à 1, représente le nbe de ligne à tester
	for (i = 0; i < 42; ++i)
		if (s[i] == 'X') {
			++c;
		}
	if (c == 4) { // si on a un alignement
		return true; 
	}
	if (s[i == '.']) { //si il y a une case vide entre 4 pions identiques
		c = 0;
	}
	else if (i == 6 * k) { // on a 6 lignes
		c = 0; //on a terminé une ligne
		++k; // on passe à la 2e ligne
	}
}
 
//vérifier l'alignement vertical
bool alignV(T2d* t, char col, unsigned int ligne) {
	unsigned int i = getHauteur(t);
	for (i; i >= 3; --i)
		if ((get(t, col, i) == 'X' && get(t, col, i - 1) == 'X' && get(t, col, i - 2) == 'X' && get(t, col, i - 3) == 'X') ||
			(get(t, col, i) == 'O' && get(t, col, i - 1) == 'O' && get(t, col, i - 2) == 'O' && get(t, col, i - 3) == 'O'))
			return true;
	return false;
}
 
//vérifier l'alignement en diagonale montante
bool alignDM(T2d* t, char col, unsigned int ligne, char* s) {
	unsigned int i = 0;
	unsigned int c = 0;//compte le nbe de symboles identiques successifs en diagonale
	unsigned int k = 1; //représente le nbe de diagonales à tester
	for (i; i < 4; i + 8)
 
		if (s[i] == 'X') {
			++c;
		}
	if (c == 4) { // si on a un alignement
		return true; 
	}
	if (s[i == '.']) { //si il y a une case vide entre 4 pions identiques
		c = 0;
	}
	else if (i == 12 * k) { 
		c = 0; 
		++k; 
	}
}
 
 
//vérifier l'alignement en diagonale descendante
bool alignDD(T2d* t, char col, unsigned int ligne, char* s) {
	for (unsigned int i = 36; i < 40; ++i)
		if ((s[i] == 'X' && s[i - 6] == 'X' && s[i - 12] == 'X' && s[i - 18] == 'X') ||
			(s[i] == 'O' && s[i - 6] == 'O' && s[i - 12] == 'O' && s[i - 18] == 'O'))
			return true;
	return false;
 
}

[dalfab]

Bonjour,

Tout d'abord je te propose d'activer les warnings de ton compilateur (la méthode dépend de ton compilateur). Il te signalera de nombreux problèmes dont celui qui te pose un problème.

Je te propose d'écrire les lignes 93 et 97 sous la forme : scanf( "%c ", &numCol );.
J'ai ajouté une espace après le %c et surtout il faut mettre l'esperluette avant numCol.
L'esperluette est nécessaire car scanf doit modifier la variable numCol et donc comme toute fonction elle ne peut modifier que ce qu'elle reçoit par adresse.
L'espace sert à gober le caractère en trop. La saisie se fait en tapant 2 touches par exemple b puis entrée, le logiciel va recevoir 2 caractères, un 'b' et un '\n'. Il te faut donc récupérer le 'b' et ignorer le '\n'.

[Ulhana]

Bonjour,

Merci beaucoup, mon problème est résolu avec votre méthode et je comprends mieux mon erreur.
J'ai également activé les warning, par contre c'est une recommandation de notre professeur pour faire fonctionner les warning qui ne marchent pas sans (même avec scanf_s).

Encore une fois, merci!

[Médinoc]

@dalfab, #define _CRT_SECURE_NO_WARNINGS ne désactive pas les warnings "normaux" de compilation, mais les warnings non-standard de Visual Studio qui disent "Utilisez notre fonction à la place de la bibliothèque standard". Ces warnings peuvent avoir leur valeur dans le monde réel, mais en milieu académique on apprend plutôt à écrire du code portable.