Tableau 2 dimension en parametre d'une fonction

[karbox]

Bonjour,

Je souhaite faire passer un tableau a 2 dimensions en parametre d'une fonction.
Je ne comprend pas pourquoi le code ci dessous ne marche pas, d'après les forums que j'ai lus ca devrait marcher.
(Je ne dois utiliser l'allocation dynamque)

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void display_grid(int **grid);
int width = 10;
int height =20;
 
int main()
{
 
	int i,j;
	int grid[width][height];
			for(i=0;i<height;i++)
			{
				for(j=0;j<width;j++)
				{
					grid[j][i] = i+j; //fill up the grid with *
				}
			}
	display_grid(grid[][height])
		return 0;
}
 
void display_grid(int **grid) //display the grid
{
	int i,j;
	for(i=0;i<height;i++)
	{
	printf("|");
		for(j=0;j<width;j++)
		{
				printf("%d",grid[j][i]);
		}
	printf("|\n");
	}
 
}

Si quelqu'un peu m'éclairer.

Merci

[Ipconfig]

Tu peux essayer cela, meme si ce n'est pas super beau....

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
const int width = 10;
const int height =20;
 
void display_grid(int grid[][height]);
 
int main()
{
 
	int i,j;
	int grid[width][height];
			for(i=0;i<height;i++)
			{
				for(j=0;j<width;j++)
				{
					grid[j][i] = i+j; //fill up the grid with *
				}
			}
		display_grid(grid);
		return 0;
}
 
void display_grid(int grid[][height]) //display the grid
{
	int i,j;
	for(i=0;i<height;i++)
	{
	printf("|");
		for(j=0;j<width;j++)
		{
				printf("%d",grid[j][i]);
		}
	printf("|\n");
	}
 
}

[souviron34]

Envoyé par karbox

Je ne comprend pas pourquoi le code ci dessous ne marche pas, d'après les forums que j'ai lus ca devrait marcher.
(Je ne dois utiliser l'allocation dynamque)

Parce que tu confonds tableaux et pointeurs...

La fonction display attend un pointeur de pointeur.
D'une part tu déclares ce que tu vas lui passer comme un tableau prédfini, et surtout tu lui passes un type ne correspondant pas à ce qu'elle attend..

Code C :

1
2
3
void display_grid(int **grid);
...
void display_grid(int grid[][height]) //display the grid

La solution simple et logique est :

Code C :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void display_grid(int **grid);
int width = 10;
int height =20;
	
int main()
{
	
	int i,j;
	int grid[width][height];
			for(i=0;i<height;i++)
			{
				for(j=0;j<width;j++)
				{
					grid[j][i] = i+j; /*fill up the grid with */
				}
			}
	display_grid(grid);
		return 0;
}
 
void display_grid(int **grid) /*display the grid*/
{
	int i,j;
	for(i=0;i<height;i++)
	{
	printf("|");
		for(j=0;j<width;j++)
		{
				printf("%d",grid[j][i]);
		}
	printf("|\n");
	}
			
}

Par contre, d'une part il serait préférable d'utiliser de l'allocation dynamique, d'autre part il serait très nettement conseillé de passer les dimensions comme arguments et non en tant que variables globales...


Enfin c'est au minimum int main (void)..

[diogene]

@souviron34 :

La solution simple et logique est :.....

Mais cette solution est fausse : pour

Code :

void display_grid(int **grid);

l'argument attendu est l'adresse d'un pointeur sur int ou un tableau de pointeurs sur int ce que n'est pas grid dans int grid[width][height] qui lui est un tableau de tableaux de int.
Le type du paramètre, si on veut passer grid en argument, doit être "adresse d'un tableau de height int" soit int (*)[height].

On doit donc déclarer

Code :

void display_grid(int (*grid)[height]);

ou son équivalent (déjà donné par Ipconfig)

Code :

void display_grid(int grid[][height]);

[souviron34]

grid n'est pas équivalent à &(grid[0][0]) ??

[diogene]

Envoyé par souviron34

grid n'est pas équivalent à &(grid[0][0]) ??

Non, le type n'est pas le même.
grid , dans le contexte considéré, est équivalent à &grid[0] (et de type int (*)[height])
C'est grid[0] qui serait équivalent à &grid[0][0] (et de type int *)

Pour la fonction :
Si le type de paramètre est int **grid, alors entre grid[0] et grid[1] il y a sizeof(int*) bytes ce qui ne correspond pas à la structure du tableau passé en argument.
Si le type de paramètre est int (*grid)[height], entre grid[0] et grid[1] il y a bien height*sizeof(int) bytes.

[souviron34]

ok alors autant pour moi...


Comme je ne manipule de toutes façons jamais des tableaux pré-alloués, surtout à plusieurs dimensions, et que surtout je ne définis jamais de fonctions ayant pour paramètre de tels tableaux, je n'ai jamais rencontré le problème...

Je me coucherai moins bête ce soir