Tableau à deux dimensions de chaîne de caractères

**auroreK** · 26/01/2015, 18h44

Bonjour,

J'aurais besoin de savoir comment réaliser un tableau à 2D de chaîne de caractère (avec à chaque case une chaîne de caractère dans un tableau, par exemple, en 5x5, sous forme de carré, de rectangles ou autre...), j'ai essayé avec cette structure mais cela ne semble pas très bien marcher :

Code :

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

1
2
3
4
5
struct abc
{
	char string[nbChar];
};
struct abc tab2D[x][y];

Je m'explique, quand je mets des valeurs (string) à l'intérieur du tableau et que je tente de les réafficher par exemple tab2D[5][0] où j'ai affecté au préalable la valeur ab2, il me retourne la valeur ab1 alors que j'attends la valeur ab2.

Aussi, au moment de où je tente d'afficher les infos, je peux utiliser, par exemple, soit tab2D[0][2].string, soit tab2D[0][2], les deux options me renvoyant des réponses différentes ce que je n'arrive pas très bien à comprendre.

Je pense alors que ma façon de construire un tableau 2D à chaîne de caract n'est pas correcte mais je ne vois pas très bien comment faire autrement.

Merci par avance !

**diogene** · 26/01/2015, 20h59

Pourquoi passer par une structure ? Une chaine est un tableau de char. Tu as besoin d'un tableau 2D de chaines, autrement dit d'un tableau 3D de char. Par exemple :

Code :

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

char tab2D[x][y][nbChar];

Chaque chaine est accessible via l'adresse tab2D[i][j] qui pointe le premier élément de la chaine (i,j)

maintenant, je ne vois pas pourquoi ta méthode avec structure ne marche pas.

**sambia39** · 26/01/2015, 21h12

Bonsoir
Ici, tu compte faire un tableau bidirectionnel c'est-à-dire, avoir une ligne par chaîne de caractères donc, techniquement, tu peux à voir autant de ligne que de nombre de chaînes de caractères soit autant de colonne que le nombre maximum de caractère dans une chaîne (mise en gras les indices nécessaires) donc, en langage de programmation C, ta demande sera alors écrite comme ceci:

Code :

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

1
2
3
4
5
6
7
8
9
 
/* Préalablement */
#define MAX 5
 
/* Ensuite */
char tChar[MAX][MAX];
 
/* Ou tableau de pointeur */
char *p_str[MAX] = { NULL };

à bientôt

**Sve@r** · 27/01/2015, 09h16

Envoyé par sambia39

Code :

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

1
2
3
4
5
6
7
8
9
 
/* Préalablement */
#define MAX 5
 
/* Ensuite */
char tChar[MAX][MAX];
 
/* Ou tableau de pointeur */
char *p_str[MAX] = { NULL };

Bonjour

Attention, il a dit "tableau2D de chaines" (en précisant "une chaine à chaque case"). Donc ce n'est pas un tableau 2D de char qu'il lui faut !!! (plus de détails dans le message de diogene à ce propos)
Et attention aussi au tableau de pointeurs car chaque pointeur devra alors être alloué.

**sambia39** · 27/01/2015, 11h37

Bonjour

Envoyé par Sve@r

Bonjour Attention, il a dit "tableau2D de chaines"

Bien vue, je me suis foiré sur la 2D[chaine] ( d'où mon +1 au poste de diogene hier) et pour ce qui est des pointeurs bien sûr qu'il faut allouer.

le code n'est pas super mais, elle peut écrire comme ceci

Code C :

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
 
/* Prog Gen test */
 
/* libC */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX	8
 
/* type data */
typedef struct s_data{
	char *p_str;
}ts_data[MAX][MAX];
 
 
int main( void ){
 
	ts_data data;
	unsigned int i = 0;
	unsigned int j = 0;
 
	for( i = 0; i < MAX; i++ ){
		for( j = 0; j < MAX; j++ ){
 
			data[i][j].p_str = (char*)calloc( MAX, sizeof(char) );
			if( data[i][j].p_str == NULL ){
				perror("_ERREUR_ (ALLOCATION)\n");
				exit( EXIT_FAILURE );
			}else{
				strcpy(data[i][j].p_str, "Bonjour" );
			}
		}
	}
	/* Affichage */
	for( i = 0; i < MAX; i++ ){
		for( j = 0; j < MAX; j++ ){
 
			printf(" %4d|[%d][%d] => %s\n", i, i, j, data[i][j].p_str );
		}
		printf("\n");
	}
 
	return (EXIT_SUCCESS);
}

à bientôt

**diogene** · 27/01/2015, 18h02

le code n'est pas super mais, elle peut écrire comme ceci ...

C'est surtout qu'il est faux

Code :

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

data[i][j].p_str = " Bonjour ";

ne copie pas dans la chaine allouée par calloc() la chaine "bonjour", mais copie l'adresse de la chaine "bonjour" dans data[i][j].p_str ce qui détruira l'adresse du tableau obtenue par le calloc() et le rendra inaccessible.

**sambia39** · 27/01/2015, 21h45

Bonsoir
Voici un bel exemple à ne pas faire, effectivement j'écrase l'adresse fournie par la fonction d'allocation.

Merci encore pour ta remarque.
à bientôt

**Sve@r** · 27/01/2015, 22h10

Envoyé par diogene

C'est surtout qu'il est faux

Code :

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

data[i][j].p_str = " Bonjour ";

ne copie pas dans la chaine allouée par calloc() la chaine "bonjour", mais copie l'adresse de la chaine "bonjour" dans data[i][j].p_str ce qui détruira l'adresse du tableau obtenue par le calloc() et le rendra inaccessible.

Bizarre, son code montre un strcpy(data[i][j].p_str, " Bonjour ") parfaitement correct et son post n'a pas été édité ??? Pourtant c'est bien ce qu'il avait mis puisqu'il le confirme... ou alors je me trompe de post ?

Envoyé par sambia39

Voici un bel exemple à ne pas faire, effectivement j'écrase l'adresse fournie par la fonction d'allocation.

Oui et un autre exemple à ne pas faire: sortir brutalement via exit() quand le x° calloc a échoué (quid des (x-1) autres qui ont réussi ???) mais implémenter une vrai gestion de ce type de cas (en libérant donc au préalable tout ce qui aura été alloué pour rien). Et (accessoirement) pourquoi remplir toute la chaine de 0 (calloc) vu que tu la remplis juste en dessous (strcpy) ???

**sambia39** · 27/01/2015, 22h42

Bonsoir,
j'ai édité mon ancien poste avec le motif et ta remarque est juste, en cas d'échec d'allocation il faut libérer l'espace alloué, mais sur le coup je ne l'ai pas fait.
Pour la fonction d'allocation c'est un choix, mais rien n'empêche de faire autrement.
à bientôt

**auroreK** · 28/01/2015, 11h28

Bonjour,

Merci pour vos réponses !

Je vous mets mon code d'origine en entier jusqu'ici : (j'ai essayé d'utiliser la solution proposée par diogene mais un problème différent apparaît dans la mesure où le tableau s'affiche mal, j'imagine que le problème ne réside pas alors dans la manière dont je construis le tableau 2D de string ?) :

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
#include <stdio.h>
#define ver 7
#define hor 7
#define taillepiece 3
#include <string.h>
 
void boardIn();
void boardOut();
 
struct echiquier
{
	char piece[taillepiece];
};
 
struct echiquier tab[ver][hor];
 
 
/////////////////////////////////
 
 
main()
{
    boardIn();
	boardOut();			
}
 
 
void boardIn()
{
	int cptTab01, cptTab02;
 
	// ajout des espaces pour remplir les cases vides du tableau
	for(cptTab01=2; cptTab01<6; cptTab01++)
	{
		for (cptTab02=0; cptTab02<8; cptTab02++)
		{
	      strcpy(tab[cptTab01][cptTab02].piece, "   ");
        }
    }
 
	// pièces noires
	strcpy(tab[1][0].piece, "PB1");
	strcpy(tab[1][1].piece, "PB2");
	strcpy(tab[1][2].piece, "PB3");
	strcpy(tab[1][3].piece, "PB4");
	strcpy(tab[1][4].piece, "PB5");
	strcpy(tab[1][5].piece, "PB6");
	strcpy(tab[1][6].piece, "PB7");
	strcpy(tab[1][7].piece, "PB8");
	strcpy(tab[0][0].piece, "RB1");
	strcpy(tab[0][1].piece, "kB1");
	strcpy(tab[0][2].piece, "BB1");
	strcpy(tab[0][3].piece, "QB ");
	strcpy(tab[0][4].piece, "KB ");
	strcpy(tab[0][5].piece, "BB2");
	strcpy(tab[0][6].piece, "kB2");
	strcpy(tab[0][7].piece, "RB2");
 
    // pièces blanches
    strcpy(tab[6][0].piece, "PW1");
	strcpy(tab[6][1].piece, "PW2");
	strcpy(tab[6][2].piece, "PW3");
	strcpy(tab[6][3].piece, "PW4");
	strcpy(tab[6][4].piece, "PW5");
	strcpy(tab[6][5].piece, "PW6");
	strcpy(tab[6][6].piece, "PW7");
	strcpy(tab[6][7].piece, "PW8");
	strcpy(tab[7][0].piece, "RW1");
	strcpy(tab[7][1].piece, "kW1");
	strcpy(tab[7][2].piece, "BW1");
	strcpy(tab[7][3].piece, "QW ");
	strcpy(tab[7][4].piece, "KW ");
	strcpy(tab[7][5].piece, "BW2");
	strcpy(tab[7][6].piece, "kW2");
	strcpy(tab[7][7].piece, "RW2");
}
 
 
void boardOut() // construction et affichage du plateau (8 valeurs : 0 à 7)
{
    int cptTab1;
    int cptTab2;
    int cptC;
 
    int cpt3 ;
 
    cpt3 = 8;
 
    printf("    A   B   C   D   E   F   G   H\n");
 
    for(cptTab1=0 ; cptTab1<8 ; cptTab1++)
    {
        printf("   --- --- --- --- --- --- --- ---\n");
        printf("%d |", cpt3);
        cpt3--;
        for(cptTab2=0 ; cptTab2<8 ; cptTab2++)
        {
            printf("%s|", tab[cptTab1][cptTab2]);  
        }
        printf("\n");
    }
    printf("   --- --- --- --- --- --- --- ---\n");
}

Vous l'aurez compris, j'essaie d'afficher un plateau d'échecs avec les pièces correspondantes, le problème ici est que les pièces ne s'affichent pas à l'endroit où on les attend (pour certains). Par exemple, on a bien RB2 en tab[0][7] comme prévu mais aussi en tab[1][0] ? Aussi, dans ce cas, aucune valeur n'apparaît en tab[1][1] ?
Je me demandais alors si le pb ne venait pas de la structure que j'utilise pour construire le tableau d'où mon interrogation lors du premier post ?
J'ai également tenté de rajouter des .piece après les tab dans les boucles for mais ça ne marche pas vraiment mieux.

J'ai essayé de voir le code proposé par sambia mais j'ai un petit problème undefined reference to... au moment de la compilation.

**ternel** · 28/01/2015, 14h56

En fait, ton problème est délicat, parce que tu n'as pas forcément choisis les meilleurs représentations.

Je te suggère d'utiliser la maquette suivante (chaque /*!*/ représente un choix à faire)

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
#includes
/* on ne met jamais de define avant un include */
#defines
 
/* les enums ajoute du sens et de la souplesse (ils se comparent avec ==) */
typedef enum piece {piece_rien, piece_pion, piece_cavalier, piece_fou, piece_tour, piece_roi, piece_reine} piece;
typedef enum joueur {joueur_aucun, joueur_blanc, joueur_noir} joueur;
 
typedef /*!*/ case_t;//une case
typedef /*!*/ echiquier_t;//le plateau complet
 
void echiquier_initialiser(echiquier_t /* pointeur selon ton typedef */ e);
 
void echiquier_afficher(echiquier_t const /* pointeur? */ e);
 
//retourne une copie d'une case du plateau
case_t echiquier_lire(echiquier_t const /* pointeur? */ e, /*!*/  ligne, /*!*/ colonne);
 
void echiquier_ecrire(echiquier_t /* pointeur? */ e, /*!*/  ligne, /*!*/ colonne, case_t /* pointeur? */ valeur);
 
void afficher_case(case_t /*pointeur?*/ c); // un printf bien pensé
 
int main() {
	echiquier_t echiquier;
	echiquier_initialiser ( /*& si pointeur*/ echiquier);
	echiquier_afficher ( /*& si pointeur*/ echiquier);
 
	return 0;
}

note: "jamais" signifie: "pas avant d'avoir une excellente raison"

par exemple, tu peux envisager (en supposant que tu utilises un pointeur):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void echiquier_afficher(echiquier_t const * e) {
    printf("    A   B   C   D   E   F   G   H\n");
 
    for (int ligne=0 ; ligne<8 ; ligne++) {
        printf("   --- --- --- --- --- --- --- ---\n");
        printf("%d |", 8-ligne);
        for (int colonne=0 ; colonne<8 ; colonne++) {
            afficher_case( echiquier_lire(e, ligne, colonne) );
            printf("|"););  
        }
        printf("\n");
    }
    printf("   --- --- --- --- --- --- --- ---\n");
}

L'idée générale, c'est d'avoir des niveaux d'abstraction.
tu dois faire un paquet souple de l'échiquier, et n'utiliser dans ton main que des fonctions.
Idéalement, tu n'accèdes pas aux détails de échiquier en dehors de fonction spécifique, exactement comme FILE* dans la bibliothèque standard (tu utilse fopen(), fclose(), fread(), fwrite(), mais tu n'utilises jamais les champs de FILE (qui ne sont d'ailleurs pas définis dans la norme))

**Sve@r** · 28/01/2015, 16h25

Envoyé par auroreK

Vous l'aurez compris, j'essaie d'afficher un plateau d'échecs avec les pièces correspondantes

Comme le dit leternel, peut-être que tu pars mal. Si c'est juste pour "afficher" alors pourquoi pas mais si tu tentes ensuite un algo de jeu contre ordinateur tu vas galérer.
Si par exemple, au lieu de stocker dans ton tableau des noms de pièces tu stockais juste un indicatif génétique (roi=1, dame=2, etc) déjà tu t'embêterais plus avec tes chaines ce qui simplifierait ton tableau. Et pour l'affichage, suffit d'afficher "K" quand la valeur est 1, "D" quand c'est 2 et etc. Bref séparer les calculs de la représentation (premiers pas vers le MVC => Modèle, Vue, Controleur, qui est une méthode de programmation utilisant ce concept). Ca permet ainsi de changer "facilement" certaines briques de code (un jour c'est en mode texte, le lendemain on le dessine dans une IHM et on a un beau jeu d'échecs 3D).

Et si tu veux ensuite partir dans un algo de jeu contre ordinateur, rien n'empêche alors de créer une structure dédiée à une pièce contenant son code génétique (1, 2, 3, etc) et sa valeur. Surtout que généralement, les pièces d'un jeu d'échec ont une valeur qui se compte en "pions". Le roi vaut 20 pions, la dame en vaut 10, la tour en vaut 5, le fou et le cavalier en valent 3 et bien évidemment chaque pion en vaut 1. Ca permet ainsi d'évaluer facilement un gain ou une perte (perdre une tour pour manger un fou ou une dame ne se verra pas de la même façon). C'est bien entendu théorique car certains joueurs préfèrent les fous d'autres les cavaliers, et sacrifier une tour au coup 18 pour avaler un fou peu se révéler payant si ça permet en plus une promotion du pion au coup 20 ; mais ce principe de valeurs permet déjà d'avoir une base d'évaluation et sert non seulement à la théorie mais aussi aux algorithmes.
Donc en mettant par exemple pour chaque pièce une valeur positive pour les blancs et négative pour les noirs, tu auras déjà créé pour ton jeu des fondations plus solides que "RB" ou "RN"...

**auroreK** · 28/01/2015, 17h39

Comme le dit leternel, peut-être que tu pars mal. Si c'est juste pour "afficher" alors pourquoi pas mais si tu tentes ensuite un algo de jeu contre ordinateur tu vas galérer.
Si par exemple, au lieu de stocker dans ton tableau des noms de pièces tu stockais juste un indicatif génétique (roi=1, dame=2, etc) déjà tu t'embêterais plus avec tes chaines ce qui simplifierait ton tableau. Et pour l'affichage, suffit d'afficher "K" quand la valeur est 1, "D" quand c'est 2 et etc. Bref séparer les calculs de la représentation (premiers pas vers le MVC => Modèle, Vue, Controleur, qui est une méthode de programmation utilisant ce concept). Ca permet ainsi de changer "facilement" certaines briques de code (un jour c'est en mode texte, le lendemain on le dessine dans une IHM et on a un beau jeu d'échecs 3D).

Ce n'est pas pour un algo de jeu vs ordi. Ce sera juste prévu pour jouer entre deux personnes réelles.

Par contre, afficher juste K ne poserait-il pas problème étant donné que toutes les pièces sont doublées au moins, voire en x16 pour les pions ?
Ou peut-être que j'ai mal compris ta réponse.

Je vais essayer d'implémenter vos propositions et vous donnerai des retours, merci !

leternel > Aussi, je ne comprends pas bien pourquoi dans le typedef enum il y a piece avant et après l'accolade ? Pareil pour joueur ? Est-ce qu'il serait suffisant de le mettre juste après l'accolade ? Merci !

**Sve@r** · 28/01/2015, 17h47

Envoyé par auroreK

Ce n'est pas pour un algo de jeu vs ordi. Ce sera juste prévu pour jouer entre deux personnes réelles.

Ce qui n'empêche pas ton programme d'évaluer le coup joué

Envoyé par auroreK

Par contre, afficher juste K ne poserait-il pas problème étant donné que toutes les pièces sont doublées au moins, voire en x16 pour les pions ?

Et alors ? Un pion reste un pion. As-tu vraiment besoin de les différencier à l'affichage ??? Si c'est vraiment le cas, alors rien ne t'empêche d'ajouter à la structure dont je parlais d'autres champs dédiée à l'enjolivement...

**auroreK** · 28/01/2015, 17h56

Oui, j'envisagerai ce point une fois que j'aurai fini quelques autres étapes !

Je pense, à l’exécution, j'ai une fenêtre très simple comparable à celle de l'invite de commandes de Windows.

Mais, désolée si certaines de mes réponses paraissent bizarre, je fais du C depuis 1 mois et certains points sont encore (très) obscurs

EDIT : j'ai réecrit le code en utilisant un tableau d'int et en essayant au mieux d'appliquer ce que vous avez conseillé mais j'ai l'impression de retomber sur les mêmes erreurs d'affichage (j'évite pour l'instant d'utiliser les pointeurs, on ne les a pas vu en cours C)

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
#include <stdio.h>
#include <string.h>
 
#define ver 7
#define hor 7
#define taillepiece 3
 
typedef case_tdef; // une case
 
void board_in(); // écriture
void board_out(); // affichage
 
case_tdef board_afficher(); // correspondance code/pièce
 
int tab[ver][hor];
 
/////////////////////////////////
 
 
main()
{
    board_in();
	board_out();			
}
 
case_tdef board_afficher(int board_ligne, int board_colonne) // W : 1, 2 ... 15, 16 ; B : -1, -2 ... -15, -16
{
	switch(tab[board_ligne][board_colonne])
	{
		case 1 : printf("pW1");
		break;
		case 2 : printf("pW2");
		break;
		case 3 : printf("pW3");
		break;
		case 4 : printf("pW4");
		break; 
		case 5 : printf("pW5");
		break; 
		case 6 : printf("pW6");
		break; 
		case 7 : printf("pW7");
		break; 
		case 8 : printf("pW8");
		break; 
		case 9 : printf("RW1");
		break; 
		case 10 : printf("kW1");
		break; 
		case 11 : printf("BW1");
		break; 
		case 12 : printf("QW ");
		break; 
		case 13 : printf("KW ");
		break; 
		case 14 : printf("BW2");
		break; 
		case 15 : printf("kW2");
		break; 
		case 16 : printf("RW2");
		break; 
		case -1 : printf("pB1");
		break;
		case -2 : printf("pB2");
		break;
		case -3 : printf("pB3");
		break;
		case -4 : printf("pB4");
		break; 
		case -5 : printf("pB5");
		break; 
		case -6 : printf("pB6");
		break; 
		case -7 : printf("pB7");
		break; 
		case -8 : printf("pB8");
		break; 
		case -9 : printf("RB1");
		break; 
		case -10 : printf("kB1");
		break; 
		case -11 : printf("BB1");
		break; 
		case -12 : printf("QB ");
		break; 
		case -13 : printf("KB ");
		break; 
		case -14 : printf("BB2");
		break; 
		case -15 : printf("kB2");
		break; 
		case -16 : printf("RB2");
		break; 
		case 99 : printf("   ");
		break;
		default : printf("ERR");
		break;
	}		
}
 
void board_in()
{
	int cptTab01, cptTab02;
 
	// implémentation code pièces blanches
	int cptTab03;
 
	cptTab03 = 1;
 
	for(cptTab01 = 6 ; cptTab01 < 8 ; cptTab01++)
	{
		for(cptTab02 = 0 ; cptTab02 < 8 ; cptTab02++)
		{
			tab[cptTab01][cptTab02] = cptTab03;
			cptTab03++;
		}
	}
 
	// implémentation code pièces noires
	cptTab03 = -1;
 
	for(cptTab01 = 1 ; cptTab01 > -1 ; cptTab01--)
	{
		for(cptTab02 = 0 ; cptTab02 < 8 ; cptTab02++)
		{
			tab[cptTab01][cptTab02] = cptTab03;
			cptTab03--;
		}
	}
 
	// ajout de la valeur 99 correspondant à un espace vide
	for(cptTab01=2 ; cptTab01<6 ; cptTab01++)
	{
		for(cptTab02=0 ; cptTab02<8 ; cptTab02++)
		{
	      tab[cptTab01][cptTab02] = 99;
        }
    }
}
 
void board_out() // construction et affichage du plateau (8 valeurs : 0 à 7)
{
    int cptTab1;
    int cptTab2;
 
    printf("    A   B   C   D   E   F   G   H\n");
 
    for(cptTab1=0 ; cptTab1<8 ; cptTab1++)
    {
        printf("   --- --- --- --- --- --- --- ---\n");
        printf("%d |", 8 - cptTab1);
        for(cptTab2=0 ; cptTab2<8 ; cptTab2++)
        {
        	board_afficher(cptTab1, cptTab2);
            printf("|");  
        }
        printf("\n");
    }
    printf("   --- --- --- --- --- --- --- ---\n");
}

J'ai joint une image où l'on peut voir l'affichage étrange qui en ressort, la ligne avec le roi et la reine ne pose pas de pb mais celle avec les pawn ne s'affiche pas correctement avec tab[6][0] qui prend 99 par exemple

**Sve@r** · 28/01/2015, 20h34

Envoyé par auroreK

EDIT : j'ai réecrit le code en utilisant un tableau d'int et en essayant au mieux d'appliquer ce que vous avez conseillé mais j'ai l'impression de retomber sur les mêmes erreurs d'affichage (j'évite pour l'instant d'utiliser les pointeurs, on ne les a pas vu en cours)

Code :

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

1
2
#define ver 7
#define hor 7

Ton erreur est ici. Avec un tableau de 7x7 pendant que tu écris sur un 8x8 tu réécris deux fois certaines cases. Et lors de l'affichage forcément...

Tu devrais utiliser des noms de variables plus simples dans tes fonctions. Parce que "board_ligne", "board_colonne", cptTab01, etc c'est bien mais ça devient super lourd à force. Mettre des noms explicites c'est bien mais faut savoir où les mettre et sur les petites variables de calculs ça ne vaut pas le coup (et pire, ça complexifie plus que ça n'aide).

Tu devrais aussi commencer à te créer des outils perso de vérification intermédiaire. Par exemple j'ai écrit cette fonction

Code c :

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

1
2
3
4
5
6
7
8
9
10
void debug_tab()
{
	int i, j;
	for (i=0; i < 8; i++)
	{
		for (j=0; j < 8; j++)
			printf("%d/%d=%d ", i, j, tab[i][j]);
		fputc('\n', stdout);
	}
}

Elle affiche le tableau en entier sous forme de valeurs. C'est en l'appelant à divers étapes de la phase de remplissage que j'ai compris. Et tu vois, pour mes variables je me suis pas cassé le luc. Seul le nom de la fonction a été écrit de façon explicite...

**ternel** · 28/01/2015, 22h36

Envoyé par auroreK

leternel > Aussi, je ne comprends pas bien pourquoi dans le typedef enum il y a piece avant et après l'accolade ? Pareil pour joueur ? Est-ce qu'il serait suffisant de le mettre juste après l'accolade ? Merci !

Pour une raison simple:
ainsi enum piece est un type, et piece un typedef dessus. L'avantage, c'est que si tu as une erreur de compilation, tu pourras avoir "enum piece" dans le message d'erreur, plutot que "anonymous enum".

Sinon, a peu près aucun. Sauf peut-être de pouvoir écrire explicitement enum piece comme type, si tu en ressent le besoin.
j'utilise juste le fait que les noms des enums, les types et les variables ne partagent pas les mêmes listes de nom.
Tu peux donc même avoir une variable nommé piece.

**auroreK** · 29/01/2015, 11h21

Citation Envoyé par auroreK Voir le message
EDIT : j'ai réecrit le code en utilisant un tableau d'int et en essayant au mieux d'appliquer ce que vous avez conseillé mais j'ai l'impression de retomber sur les mêmes erreurs d'affichage (j'évite pour l'instant d'utiliser les pointeurs, on ne les a pas vu en cours)

Code :

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

1
2
#define ver 7
#define hor 7

Ton erreur est ici. Avec un tableau de 7x7 pendant que tu écris sur un 8x8 tu réécris deux fois certaines cases. Et lors de l'affichage forcément...

Tu devrais utiliser des noms de variables plus simples dans tes fonctions. Parce que "board_ligne", "board_colonne", cptTab01, etc c'est bien mais ça devient super lourd à force. Mettre des noms explicites c'est bien mais faut savoir où les mettre et sur les petites variables de calculs ça ne vaut pas le coup (et pire, ça complexifie plus que ça n'aide).

Tu devrais aussi commencer à te créer des outils perso de vérification intermédiaire. Par exemple j'ai écrit cette fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void debug_tab()
{
	int i, j;
	for (i=0; i < 8; i++)
	{
		for (j=0; j < 8; j++)
			printf("%d/%d=%d ", i, j, tab[i][j]);
		fputc('\n', stdout);
	}
}

Elle affiche le tableau en entier sous forme de valeurs. C'est en l'appelant à divers étapes de la phase de remplissage que j'ai compris. Et tu vois, pour mes variables je me suis pas cassé le luc. Seul le nom de la fonction a été écrit de façon explicite...

D'accord... J'ai considéré que le tableau commençait par 0 et qu'il était seulement nécessaire par conséquent de ne fixer la valeur qu'à 7 (1 + 7). Cela veut dire que pour les lignes et colonnes d'un tableau, il est nécessaire d'afficher la capacité maximale sans prendre en compte le 0... Merci !

Je vois, merci beaucoup pour ces conseils, je m'efforcerai de les appliquer.

Citation Envoyé par auroreK Voir le message
leternel > Aussi, je ne comprends pas bien pourquoi dans le typedef enum il y a piece avant et après l'accolade ? Pareil pour joueur ? Est-ce qu'il serait suffisant de le mettre juste après l'accolade ? Merci !
Pour une raison simple:
ainsi enum piece est un type, et piece un typedef dessus. L'avantage, c'est que si tu as une erreur de compilation, tu pourras avoir "enum piece" dans le message d'erreur, plutot que "anonymous enum".

Sinon, a peu près aucun. Sauf peut-être de pouvoir écrire explicitement enum piece comme type, si tu en ressent le besoin.
j'utilise juste le fait que les noms des enums, les types et les variables ne partagent pas les mêmes listes de nom.
Tu peux donc même avoir une variable nommé piece.

C'est bien compris, merci !

**ternel** · 29/01/2015, 13h15

Ce n'est pas "augmenter la capacité", mais traduire l'entrée utilisateur (dans 1..8) à un index valide (dans 0..7), ce qui se fait assez immédiatement.

Quand tu déclares un tableau, entre les crochets, tu indiques le nombre d'élément N, qui seront accessible par [0], [1] .. [N-1].

En pratique, pour toute déclaration de la forme, int tab[7];, accéder à tab[7] est une faute.
C'est pour ca qu'on utilise une boucle stricte.

Code :

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

1
2
3
4
int tab[7] = {8,7,6,5,4,3,2,1};
for (int i = 0; i < 7; ++i) {
    printf("le %deme élément est tab[%d]=%d", (i+1), i, tab[i]);
};

**Sve@r** · 29/01/2015, 16h24

Envoyé par auroreK

D'accord... J'ai considéré que le tableau commençait par 0 et qu'il était seulement nécessaire par conséquent de ne fixer la valeur qu'à 7 (1 + 7). Cela veut dire que pour les lignes et colonnes d'un tableau, il est nécessaire d'afficher la capacité maximale sans prendre en compte le 0...

Euh ben oui. Quand tu définis un tableau tu le définis d'abord par sa capacité "c". Ensuite, les indices, eux, c'est autre chose. Ils partent d'une valeur "v" (fixée par les créateurs du langage) pour référencer le premier élément et vont alors jusqu'à "v+c-1" pour référencer le dernier...

Tableau à deux dimensions de chaîne de caractères

C

Discussions similaires

Partager

Partager