Discussion :

[Lordryder]

Bonjour, je suis entrain de faire un petit jeu mais je rencontre des problèmes lors des appels des fonctions dans mon main.c. J'ai créé un tableau[9][9] qui stocke le "niveau" du jeu et pour le moment j'essaye juste de déplacer des symboles d'une case x,y jusqu'à une autre dans ce même tableau, j'ai donc créé des fonctions de déplacement mais je rencontre une erreur pour l'argument (du tableau 9x9) lors de l'appel, ça ne compile pas.

Voilà donc un bout de 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
void verticalMove (char map[9][9], int fromX, int fromY, int toX, int toY)
{
	int l = 0;
 
	if (toY < fromY) //Haut
	{
		for (l = (fromY - 1); l <= (toY - 1); l--)
		{
			if (map[l][fromX] != ' ')
			{
				printf("\nDeplacement impossible: un symbole bloque le passage\n");
 
				return;
			}
		}
 
		map[toY][toX] = map[fromY][fromX];
		map[fromY][fromX] = ' ';
	}
 
	if (toY > fromY) //Bas
	{
		for (l = (fromY - 1); l <= (toY - 1); l++)
		{
			if (map[l][fromX] != ' ')
			{
				printf("\nDeplacement impossible: un symbole bloque le passage\n");
 
				return;
			}
		}
 
		map[toY][toX] = map[fromY][fromX];
		map[fromY][fromX] = ' ';
	}
}

Et je l'appel de cette façon dans le main: verticalMove(map, fromX, fromY, toX, toY);
Avec map étant un char map[9][9] et les autres variables des int.

Bon là dans le code, je suis conscient que ça ne changera rien dans mon tableau initial vu que je ne passe pas par adresse, mais c'est justement là le problème, j'ai essayé plusieurs combinaison mais à chaque fois ca plante à la compilation, ca me dis, l'argument de la fonction est un char (*)[9] mais un char [9][9] est fourni, des messages dans ce genre.

Voilà, si quelqu'un pouvais m'aider, j'ai encore quelque problème avec les pointeurs et les passages par adresse, surtout lorsqu'il s'agit de tableau à double dimension.

[Neckara]

Ce code compile parfaitement chez moi :

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
#include <stdio.h>
#include <stdlib.h>
 
void verticalMove (char map[9][9], int fromX, int fromY, int toX, int toY)
{
	int l = 0;
 
	if (toY < fromY) //Haut
	{
		for (l = (fromY - 1); l <= (toY - 1); l--)
		{
			if (map[l][fromX] != ' ')
			{
				printf("\nDeplacement impossible: un symbole bloque le passage\n");
 
				return;
			}
		}
 
		map[toY][toX] = map[fromY][fromX];
		map[fromY][fromX] = ' ';
	}
 
	if (toY > fromY) //Bas
	{
		for (l = (fromY - 1); l <= (toY - 1); l++)
		{
			if (map[l][fromX] != ' ')
			{
				printf("\nDeplacement impossible: un symbole bloque le passage\n");
 
				return;
			}
		}
 
		map[toY][toX] = map[fromY][fromX];
		map[fromY][fromX] = ' ';
	}
}
 
int main()
{
    char c[9][9];
    verticalMove(c, 1, 1, 2, 2);
    return 0;
}

Pourrais-tu nous donner l'ensemble du code ainsi que les messages (et lignes) donnés par le compilateurs?


Sinon, lorsqu'on passe un tableau en argument d'une fonction, le tableau n'est pas copié, seul l'adresse l'est ainsi :
- si tu passe un char[9], tu peux décider dans ta fonction que c'est un pointeur sur un char : char * ou un tableau de 9 char : char[9]

- si tu passe un char[9][8], tu peux décider dans ta fonction que c'est un pointeur de pointeur sur un char : char ** ou un pointeur sur un tableau de 8 char : char (*)[8] ou un tableau à deux dimension : char [9][8]

Ne pas confondre char (*)[] qui est un pointeur sur un tableau de char et char * [] qui est un tableau de pointeur sur des char.

[Bktero]

- si tu passe un char[9][8], tu peux décider dans ta fonction que c'est un pointeur de pointeur sur un char : char ** ou un pointeur sur un tableau de 8 char : char (*)[8] ou un tableau à deux dimension : char [9][8]

J'ai un doute sur le char**, qui n'est pas équivalent à un char (*)[] puisque l'un est un pointeur sur pointeur alors que l'autre est un pointeur sur un tableau. On en a parlé au début de la semaine ici.

En reprenant le post de diogene, si le paramètre formel est de type char**, alors l'objet passé devra est de type tableau de pointeur ou pointeur sur pointeur ; mais pas un tableau de tableau de char. Si on compile, le code suivant :

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
#include <stdlib.h>
 
void f1(char mat[][5])
{
    mat[0][0] = 0;
}
 
void f2(char **pt)
{
    pt = NULL;
}
 
int main(void)
{
    char mat[5][5];
    char *tab[5];
 
    f1(mat);
    f2(mat);
 
    f1(tab);
    f2(tab);
 
    return 0;
}

On obtient les warning suivants :

Code :

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

1
2
3
4
5
6
d:\...\main.c||In function 'main':|
d:\...\main.c|19|warning: passing argument 1 of 'f2' from incompatible pointer type|
d:\...\main.c|8|note: expected 'char **' but argument is of type 'char (*)[5]'|
d:\...\main.c|21|warning: passing argument 1 of 'f1' from incompatible pointer type|
d:\...\main.c|3|note: expected 'char (*)[5]' but argument is of type 'char **'|
||=== Build finished: 0 errors, 2 warnings (0 minutes, 0 seconds) ===|

Pour répondre à la question "pourquoi ça ne compile pas", il faudrait voir l'appel à la fonction, ainsi que la déclaration de l'objet qui est passé en paramètre.

[diogene]

Pour compléter la juste remarque de Bktero, on peut aussi critiquer cette phrase

- si tu passe un char[9], tu peux décider dans ta fonction que c'est un pointeur sur un char : char * ou un tableau de 9 char : char[9]

Que la déclaration soit f(char a[9]) ou f(char a[])ou f(char *a), a sera toujours un char * dans la fonction f().
C'est le seul cas (c'est à dire dans une liste de déclaration de paramètres) où on peut indifféremment mettre une déclaration du genre tableau ou du genre pointeur.

[Neckara]

J'ai un doute sur le char**, qui n'est pas équivalent à un char (*)[] puisque l'un est un pointeur sur pointeur alors que l'autre est un pointeur sur un tableau.

Je n'ai jamais dit qu'ils étaient équivalant, je me suis peut être mal exprimé.

Ce que je voulais dire c'est que si on veut passer à une fonction x un char[][], on a trois choix de prototypes :

Code :

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

1
2
3
void x(char x[9][9]);
void x(char (*)[9]);
void x(char **); // par contre là il faut faire un cast (char **) lors de l'appel.

Après savoir quel est le meilleurs prototype... Je pense qu'il faut regarder au cas par cas.

Que la déclaration soit f(char a[9]) ou f(char a[])ou f(char *a), a sera toujours un char * dans la fonction f().
C'est le seul cas (c'est à dire dans une liste de déclaration de paramètres) où on peut indifféremment mettre une déclaration du genre tableau ou du genre pointeur.

Je savais quel seul le pointeur était copié, mais je ne pensais pas qu'il était considéré en tant que pointeur et non en tant que tableau ainsi :

Code :

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

1
2
3
4
void f(char c[9])
{
           sizeof(c); // = sizeof(char *);
}

[Jean-Marc.Bourguet]

Ce que je voulais dire c'est que si on veut passer à une fonction x un char[][], on a trois choix de prototypes :

Code :

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

1
2
3
void x(char x[9][9]);
void x(char (*)[9]);
void x(char **); // par contre là il faut faire un cast (char **) lors de l'appel.

Après savoir quel est le meilleurs prototype... Je pense qu'il faut regarder au cas par cas.

Les deux premiers prototypes sont équivalents (dans le premier, le premier 9 a la valeur d'un commentaire.)

Le deuxième par contre déclare une fonction bien différente. On ne peut pas lui passer un tableau de tableau (alias tableau bidimensionnel), il faut lui passer un tableau de pointeurs vers des tableaux de valeurs. Et lui passer une variable définie par un char tab[9][9] va poser des problèmes si tu castes pour éviter l'erreur que le compilateur te donnera pour te signifier que tu vas droit dans le mur.

[Neckara]

Je pense que je viens de comprendre, les tableaux à plusieurs dimensions n'existent que lors de la compilation, lors de l’exécution ce ne sont que des tableaux à une dimension.

Ainsi pour un tableau déclaré comme ceci : char c[3][3][3], char c[2] n'existe pas.

Par contre lorsqu'on va faire : c[x][y]; ou &c[x][y] on va obtenir l'adresse de l'élément c[x][y][0] de même avec c[x] où on obtient l'adresse de l'élément c[x][0][0].
Je suppose que c'est pour faciliter les affectations char * d = c[x][y] ?

[Jean-Marc.Bourguet]

Je pense que je viens de comprendre, les tableaux à plusieurs dimensions n'existent que lors de la compilation, lors de l’exécution ce ne sont que des tableaux à une dimension.

Je me répète, en C il n'y a pas de tableaux multidimensionnel, il n'y a que des tableaux de tableaux de ... tableaux qu'on appelle improprement des tableaux multidimensionnel.

Ainsi pour un tableau déclaré comme ceci : char c[3][3][3], char c[2] n'existe pas.

Si. C'est un tableau a 2 dimensions. Qui sera converti en un pointeur vers son premier element (qui peut s'ecrire &c[3][0] et qui est de type pointeur vers tableau de 3 char) dans la plupart des contextes (operande de & et de sizeof sont les exceptions en C). Tu peux donc faire un sizeof c[2] ou passer &c[2] a une fonction attendant un char (*param)[3][3].

Par contre lorsqu'on va faire : c[x][y]; ou &c[x][y] on va obtenir l'adresse de l'élément c[x][y][0] de même avec c[x] où on obtient l'adresse de l'élément c[x][0][0].

c[x][y] est de type pointeur vers 3 char (et sera tres facilement converti en un pointeur vers char pointant vers c[x][y][0]).

&c[x][y][0] est de type pointeur vers char (et va se comporter differement de c[x][y] en tant qu'operande de sizeof et de &).

[Neckara]

Si. C'est un tableau a 2 dimensions. Qui sera converti en un pointeur vers son premier element (qui peut s'ecrire &c[3][0] et qui est de type pointeur vers tableau de 3 char) dans la plupart des contextes (operande de & et de sizeof sont les exceptions en C). Tu peux donc faire un sizeof c[2] ou passer &c[2] a une fonction attendant un char (*param)[3][3]

Ce que je voulais dire c'est que char c[2] n'est pas une variable qui sera stockée en mémoire, elle n'a de signification que par le compilateur à la différence de :

Code :

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

char ** c = malloc(sizeof(char*) * 10);

où c[2];existe vraiment et sera stockée en mémoire.

[Jean-Marc.Bourguet]

Ce que je voulais dire c'est que char c[2] n'est pas une variable qui sera stockée en mémoire

Une variable etant un object nomme, c est une variable et c[2] n'en est pas une. Mais c'est un objet. De type tableau de 3 tableaux de 3 char. De taille 9 bytes et situe en memoire de maniere contigue a c[1], lui meme situe en memoire de maniere contigue a c[0].

c, c[0], c[0][0], c[0][0][0] sont trois objets commencant a la meme adresse et de taille differentes (27, 9, 3 et 1). Tout comme dans

Code :

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

1
2
3
4
5
6
7
8
9
10
 
struct t1 {
   char o0, o1, o2;
};
struct t2 {
   struct t1 o0, o1, o2;
};
struct t3 {
   struct t2 o0, o1, o2;
} tableau;

tableau, tableau.o0, tableau.o0.o0, tableau.o0.o0.o0 sont trois objets commencant a la meme adresse et de taille differentes (la taille ici est dependante de l'implementation 27, 9, 3, 1 et 36, 12 , 4 , 1 sont les plus probables).

c[2] existe tout autant que tableau.o2 existe (et aucun des deux n'est une variable)

[Neckara]

D'accord, je ne voyais pas cela sous cet angle mais si on considère que :

c, c[0], c[0][0], c[0][0][0] sont trois objets commencant a la meme adresse et de taille differentes (27, 9, 3 et 1).

J'ai juste un problème avec la valeur de c, c[0], c[0][0] car leur valeur n'est pas stockée en mémoire, leur valeur est en fait leur propre adresse (quand on fait un printf("%d" par exemple) ).
J'ai plus l'impression que ce sont de "defines" que des "structures" dans le sens où j'ai l'impression que dans printf("%d", c[0]), c[0] va directement être remplacé par le compilateur au lieu de rechercher en mémoire la valeur de c[0] (qui par ailleurs ne s'y trouvera pas).

Désolé pour ce petit HS et merci pour vos réponses.

[Jean-Marc.Bourguet]

D'accord, je ne voyais pas cela sous cet angle mais si on considère que :

J'ai juste un problème avec la valeur de c, c[0], c[0][0] car leur valeur n'est pas stockée en mémoire, leur valeur est en fait leur propre adresse (quand on fait un printf("%d" par exemple) ).

A nouveau, la valeur de c, ce sont les 27 bytes du tableau, celle de c[0] c'est les 9 bytes du premier element, celle de c[0][0] c'est les 3 bytes du premier element du premier element. Tout comme avec tableau, tableau.o0, tableau.o0.o0, tableau.o0.o0.o0.

Le probleme, c'est que lors de la transition de BCPL vers C, on n'a pas acheve le mouvement. Donc on ne peut pas faire c[0] = c[1] ou passer un tableau par valeur a une fonction. Et en prime, on a garde la conversion implcite d'un tableau en un pointeur vers son premier element et la syntaxe lors de la declaration de fonction qui permet de declarer une fonction prenant un pointeur avec la syntaxe qui devrait etre reservee pour une fonction prenant un tableau par valeur. Plus le temps passe, moins j'utilise ces possibilites parce que, si elles sont un peu plus legere quand on sait ce qu'on fait et qu'elles permettent de documenter qu'un parametre doit pointer vers un tableau, elles perpetuent aussi la confusion.

[Bktero]

Plus le temps passe, moins j'utilise ces possibilites parce que, si elles sont un peu plus legere quand on sait ce qu'on fait et qu'elles permettent de documenter qu'un parametre doit pointer vers un tableau, elles perpetuent aussi la confusion.

Qu'arrêtes-tu de faire et que tu fais tu as la place ?

[Neckara]

Si j'ai bien compris, il ne fait pas :
void x(char c [9][9]) mais void x(char (*c)[9] )
Et il n'utilise pas non plus :

Code :

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

1
2
char c[2][2];
char * d = c[0];

?

[Jean-Marc.Bourguet]

Qu'arrêtes-tu de faire et que tu fais tu as la place ?

Je déclare mes fonctions avec void f(int *tab); plutôt que void f(int tab[]);, et je les appelles avec f(&tab[0]) plutot que f(tab) (la première est maintenant systématique chez moi, je ne suis pas encore totalement consistant pour la deuxième, en particulier quand il s'agit de manipuler des chaînes de caractères).

[Bktero]

En gros, tu écris directement le résultat de la conversion implicite, pour que tout soit explicite ?

Qu'écris-tu pour les tableaux multidimensionnels ?

Pour allez plus loin dans ce débât (si on dévie, un gentil modo découpera le sujet ), que penses-tu simplement de l'utilisation des tableaux ? J'ai écrit un article pour résumer ce qu'il s'est dit d'intéressant sur le sujet "tableaux != pointeurs" ces derniers jours, et j'ai eu un débat avec un ami sur Google Chat à la suite de ça. Lui me disait qu'il n'utilisait pas du tout de tableaux, qu'ils faisaient tout avec pointeur / malloc / free. Je ne sais pas trop quoi penser de cette approche.

[Jean-Marc.Bourguet]

En gros, tu écris directement le résultat de la conversion implicite, pour que tout soit explicite ?

Plutot pour que ca corresponde a mon modele mental. Avec dans f(&tab[0]) plutot que f(tab) une tension parce que ce n'est pas tres idiomatique (pour la declaration de fonction, j'ai l'impression que les deux ecritures se rencontrent couremment, donc il n'y a pas cette tension).

Qu'écris-tu pour les tableaux multidimensionnels ?

Code :

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

1
2
void f(int (*tab)[N]);
f(&tab[0])

Pour allez plus loin dans ce débât (si on dévie, un gentil modo découpera le sujet ), que penses-tu simplement de l'utilisation des tableaux ? J'ai écrit un article pour résumer ce qu'il s'est dit d'intéressant sur le sujet "tableaux != pointeurs" ces derniers jours, et j'ai eu un débat avec un ami sur Google Chat à la suite de ça. Lui me disait qu'il n'utilisait pas du tout de tableaux, qu'ils faisaient tout avec pointeur / malloc / free. Je ne sais pas trop quoi penser de cette approche.

Pour moi,

Code :

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

1
2
3
 
double *foo = malloc(N*sizeof double);
foo[4]

c'est de l'utilisation d'un tableau. Le systeme de type ne m'encourage pas (ou ne me permet pas quand N n'est pas constant) a le specifier, mais ca reste mon modele interne. Je ferai le choix entre l'allocation dynamique et automatique -- la pile -- ou statique -- variable globale -- exactement comme je le ferai pour une struct. (Avec une raison de plus N peut ne pas etre fixe statiquement, et un facteur qui entre en compte plus souvent pour les tableaux que pour les structs, N peut etre tres grand ce qui pousse a utiliser l'allocation dynamique plutot qu'automatique, les piles etant generalement de taille limitee)

[Lordryder]

Oula ... je n'ai pas tout suivi là ... Mon problème c'est que je donne donc bien un tableau 9x9 à la fonction, qui après me déplace le symbole d'une case x,y à une autre, mais à la sortie de cette fonction, le résultat n'est pas sauvegardé, si je reaffiche mon tableau avec une fonction printf dans mon main.c, et bien les symboles sont tjrs à leur place d'avant entrer dans la fonction.

Donc d'après ce que j'ai compris pour que ca change direct dans le tableau de depart, il faut passer par adresse mais quand j'essaye ca, j'ai des erreur de compilation, je ne sais pas très bien comment marquer tout ca en fait, si il faut que j'écrive &map[9][9] ou **map ou *map[9], etc ...

[Jean-Marc.Bourguet]

La discussion a divergé. Il faut dire que ce que tu as montre ne permet pas de mettre en evidence le probleme dont tu te plains si on complete le code de maniere raisonnable.

Donc comme souvent, donne un exemple complet et aussi minimal que possible qui permet de reproduire le probleme sans faire d'hypotheses sur ce que tu fais ailleurs.

Ici il faudrait un main qui appelle VerticalMove.

[Lordryder]

... Finalement, c'était une erreur des plus bêtes, je donnais en argument des coordonnee fromY, fromX, ... pour trouver le symbole dans le tableau mais ces coordonnées étaient des chiffres de 1 à 9 et non pas 0 à 8 vu que pour les tableaux le premier élèments est en [0] ... donc finalement, la fonction marche mais elle prenait la mauvaise case

Moi qui croyais que c'était un problème de passage par adresse, pointeur ... Désolé du dérangement.