Questions sur les tableaux

Version imprimable

13/01/2008, 14h34
ciol2.6.12

Questions sur les tableaux
Bonjour, pourquoi je peux pas faire :
Code:

1 2 3 4 5 6 7 void foo(int **tab) { } int tab[5][10]; foo(tab); /* erreur */
Autre question sans rapport : pourquoi je peux pas faire :

Code:

int tab[][] = { {1, 1}, {1, 1} };

?

Merci.
13/01/2008, 14h55
Sve@r
Citation:
Envoyé par ciol2.6.12

Bonjour, pourquoi je peux pas faire :

Code:

1 2 3 4 5 void foo(int **tab) { } int tab[5][10];
Parce que un tableau, même en plusieurs dimensions, n'est traduit en mémoire qu'en une seule dimension (une suite de cases). Donc pour aller sur l'élément tab[x][y], le C est obligé de traduire ça en "case mémoire située à l'emplacement x * 10 + y".
Or, dans la fonction foo, l'élément "tab" n'est plus qu'un pointeur et le C ne connait pas sa largeur "10"
Code:

1 2 3 void foo(int *tab[10]) { }
Citation:

Envoyé par ciol2.6.12

Autre question sans rapport : pourquoi je peux pas faire :

Code:

int tab[][] = { {1, 1}, {1, 1} };

?

Merci.

Même réponse. Tu n'as le droit de n'omettre que la dernière des dimensions (celle qui est la plus proche du nom de variable). Le compilo utilise toutes les autres plus ta déclaration pour la calculer.

Code:

int tab[][2] = { {1, 1}, {1, 1} };
13/01/2008, 15h01
Linu6

Le deuxième indice ne peut pas être omis.

essaye

Code:

void foo(int **tab, int y)

où y = deuxième indice.

Code:

int tab[][] = { {1, 1}, {1, 1} };

Le compilateur ne connait pas la taille maximale du deuxième indice.
13/01/2008, 15h23
Trap D

Sve@r >> Ce ne serait pas plutôt void foo(int tab[][10]) ?
13/01/2008, 15h25
Sve@r

Citation:

Envoyé par Linu6

Code:

void foo(int **tab, int y)

où y = deuxième indice

Ah non. Le problème vient de la transformation de "[m][n]" en "m * largeur + n". Et cette transformation est faite par le compilo. Et le compilo ne sait pas que le second paramètre est la largeur qu'il attend...

Citation:

Envoyé par Trap D

Sve@r >> Ce ne serait pas plutôt void foo(int tab[][10]) ?

Ouaip. Mais comme la dernière dimension peut être remplacée par une étoile, j'ai voulu me rapprocher le plus possible de l'écriture initiale...
13/01/2008, 15h27
Linu6
Citation:

Envoyé par Trap D

Sve@r >> Ce ne serait pas plutôt void foo(int tab[][10]) ?

a mon avis il y a une équivalence entre
Code:

1 2 3 4 char *tab[MAXY],; char tab[][MAXY]; et (char **tab, int y);
13/01/2008, 15h28
Sve@r
Citation:
Envoyé par Linu6

a mon avis il y a une équivalence entre

Code:

1 2 char *tab[MAXY],; char tab[][MAXY];
Oui

Citation:

Envoyé par Linu6

et

Code:

(char **tab, int y);

Non
13/01/2008, 15h32
Linu6

:roll: :oops:
13/01/2008, 15h48
Médinoc

Il me semble que ce n'est pas char *tab[MAXY], mais char (*tab)[MAXY]...
13/01/2008, 16h04
ciol2.6.12

Citation:

Envoyé par Sve@r

Parce que un tableau, même en plusieurs dimensions, n'est traduit en mémoire qu'en une seule dimension (une suite de cases). Donc pour aller sur l'élément tab[x][y], le C est obligé de traduire ça en "case mémoire située à l'emplacement x * 10 + y".
Or, dans la fonction foo, l'élément "tab" n'est plus qu'un pointeur et le C ne connait pas sa largeur "10"

Et comment le C fait pour les pointeurs alors ?
Si je fais :
int **tab = ...;
tab[x][y] = 2;

Il sait où il faut aller pourtant.

Citation:

Envoyé par Sve@r

Tu n'as le droit de n'omettre que la dernière des dimensions (celle qui est la plus proche du nom de variable). Le compilo utilise toutes les autres plus ta déclaration pour la calculer.

Je ne vois pas pourquoi il ne peut pas retrouver les dimensions. Il a tous les éléments pour le faire (2 x {} et dans chaque {}, 2 élements -> tableau [2][2]).
13/01/2008, 16h27
Thierry Chappuis
Citation:
Envoyé par Linu6

a mon avis il y a une équivalence entre

Code:

1 2 3 4 char *tab[MAXY],; char tab[][MAXY]; et (char **tab, int y);
Pas du tout, l'équivalence a lieu entre:
Code:

1 2 void foo(char (*tab)[MAXY]); /* -tc- les parentheses sont importantes! */
et

Code:

void foo(char tab[][MAXY]);

qui ne sont absolument pas équivalent à:

Code:

void foo(char **tab, size_t y);

Dans les deux premier cas, le paramètre tab est de type pointeur sur un tableau de MAXY chars, tandis que dans le 3ème cas, tab est de type pointeur sur pointeur sur char.

Thierry
13/01/2008, 16h35
Thierry Chappuis
Citation:

Envoyé par ciol2.6.12

Et comment le C fait pour les pointeurs alors ?
Si je fais :
int **tab = ...;
tab[x][y] = 2;

Il sait où il faut aller pourtant.

Parce que tab[x][y] est implicitement converti en:
Code:

1 2 *(*(tab + x) + y);
où tab est de type pointeur sur pointeur sur int. En C, tableaux et pointeurs sont différents. Par contre, il y a équivalence entre l'arthimétique des pointeurs et l'accès par indiçage (c'est français ça?) à un tableau.

Thierry
13/01/2008, 16h42
ciol2.6.12

OK.
En fait un tableau pur est linéaire.
Alors qu'un pointeur de pointeurs non.

C'est ce qu'avait dit Sve@r.

Comment ai-je pu oublier ?

Par contre ma deuxième question tient toujours.
13/01/2008, 16h52
Sve@r

Citation:

Envoyé par ciol2.6.12

Et comment le C fait pour les pointeurs alors ?
Si je fais :
int **tab = ...;
tab[x][y] = 2;

Il sait où il faut aller pourtant.

Oui. Mais
- sois tu fais "tab=autre_tableau" avec "autre_tableau" défini comme il faut. Donc il y a équivalence entre "tab" et "autre_tableau" => le C sais adresser "tab[x]|y]" puisqu'il se base sur les dimensions de "autre_tableau" pour le faire

- sois tu fais "tab=malloc(n * sizeof(*tab))" puis "for (x=0; x < n; x++) tab[x]=malloc(m * sizeof(**tab)". Et là, le C sait aller sur tab[x] qui est le "xième" pointeur pris à partir de tab puis, de tab[x], il sait se déplacer sur l'élément [y] qui est le "yième" élément pris à partir de tab[x]. Autrement dit tab[x][y] n'est qu'une double indirection.
Dans cette dernière écriture, il n'y a aucune obligation que l'ensemble du tableau soit contigü. T'as simplement tab qui contient un tableau de pointeurs (qui se suivent) mais chaque pointeur pointe vers une zone de la mémoire totalement diverse (et pas forcément aux mêmes endroits).

Citation:

Envoyé par ciol2.6.12

Je ne vois pas pourquoi il ne peut pas retrouver les dimensions. Il a tous les éléments pour le faire (2 x {} et dans chaque {}, 2 élements -> tableau [2][2]).

Toi tu sais le faire. Moi aussi. Mais le compilo qui n'est qu'un simple programme qui n'a pas été fait pour ça, ne sait pas le faire.
Inversement, si on voulait programmer un compilo qui sache le faire, il faudrait lui introduire un algorithme récursif (vu qu'on ne saurait pas à l'avance le nombre de dimensions max) pour analyser l'écriture.
13/01/2008, 16h55
Thierry Chappuis
Citation:

Envoyé par ciol2.6.12

Par contre ma deuxième question tient toujours.

Parce qu'un tableau deux dimensions, ça n'existe pas réellement en C. Lorsque tu définis:

Code:

int tab[3][4];

Tu définis un tableau de 3 tableaux de 4 ints. Ainsi, ce n'est rien d'autre qu'un tableau à une dimension contenant des éléments de type tableau de 4 int. Lorsque tu définis ton tableau, tu ne peux pas écrire:

Code:

int tab[][] = {{1,1}, {1,1}, {1,1}}; /* -tc- ATTENTION: Ceci est faux! */

,

Car le type des éléments du tableaux n'est pas défini. Tu dois donc écrire:
Code:

1 2 int tab[][2] = {{1,1}, {1,1}, {1,1}};
qui correspond à la forme:
Code:

1 2 type identificateur_tableau[] = initialisation
où type est un tableau de 2 ints.

Thierry
13/01/2008, 17h02
Trap D

Citation:

Envoyé par Médinoc

Il me semble que ce n'est pas char *tab[MAXY], mais char (*tab)[MAXY]...

Eh oui ! sinon plante.
13/01/2008, 17h03
diogene

Sve@r :

Citation:

Citation:

Et comment le C fait pour les pointeurs alors ?
Si je fais :
int **tab = ...;
tab[x][y] = 2;

Il sait où il faut aller pourtant.

Oui. Mais
- sois tu fais "tab=autre_tableau" avec "autre_tableau" défini comme il faut. Donc il y a équivalence entre "tab" et "autre_tableau" => le C sais adresser "tab[x]|y]" puisqu'il se base sur les dimensions de "autre_tableau" pour le faire
....

Il n'a absolument pas besoin de se baser sur les dimensions de quelque chose d'autre. tab[x] est un int * et il connait la taille d'in int * donc il peut situer tab[x]. tab[x][y] est un int. Il sait situer tab[x], il connait la taille d'un int ; il peut situer tab[x][y]
13/01/2008, 21h21
Emmanuel Delahaye
Citation:
Envoyé par ciol2.6.12

Bonjour, pourquoi je peux pas faire :

Code:

1 2 3 4 5 6 7 void foo(int **tab) { } int tab[5][10]; foo(tab); /* erreur */
Parce qu'un pointeur de pointeur n'a rien à voir avec un tableau linéaire à 2 dimensions. Tu confonds avec les tableaux dynamiques à 2 dimensions formés d'un tableau de pointeurs et de tableaux 'accrochés' à ces pointeurs...

Citation:

Autre question sans rapport : pourquoi je peux pas faire :

Code:

int tab[][] = { {1, 1}, {1, 1} };

?

Parce que le langage C ne l'autorise pas. Il autorise
Code:

1 2 3 4 int tab[4][5] = { {1, 1}, {1, 1} }; int tab[][5] = { {1, 1}, {1, 1} }; int tab[2][2] = { {1, 1}, {1, 1} }; int tab[][2] = { {1, 1}, {1, 1} };
etc. Mais pas

Code:

int tab[4][] = { {1, 1}, {1, 1} };

ni

Code:

int tab[][] = { {1, 1}, {1, 1} };

Citation:

Envoyé par ciol2.6.12

Bonjour, pourquoi je peux pas faire :
...
Merci.

Tu confonds tableaux et pointeurs.

Code:

int t[10];

déclare un tableau de 10 entiers. Le type de t est int [10] (tableau de 10 entiers). Ici, sizeof(t) = 10 * sizeof(int).

Code:

int t[5][10];

déclare un tableau de 5 int [10]. En mémoire c'est tout simplement donc un tanleau de 50 int. Un tableau à deux dimensions est un tableau, pas un pointeur de pointeurs. Ici sizeof(t) = 5 * sizeof(int [10]) = 5 * 10 * sizeof(int). Un int * (mais pas un int **) permet donc de pointer sur t, mais un cast est nécessaire.

Code:

int * t[5];

déclare un tableau de 5 pointeurs (int *). Ici, sizeof(t) = 5 * sizeof(int *).

On peut aussi initialiser un tableau pendant sa déclaration. Par exemple :

Code:

int t[10] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};

Ceci est strictement équivalent à :

Code:

int t[] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};

Un autre exemple :
Code:

1 2 3 4 5 6 7 int t[5][10] = { {0, 10, 20, 30, 40, 50, 60, 70, 80, 90}, {1, 11, 21, 31, 41, 51, 61, 71, 81, 91}, {2, 12, 22, 32, 42, 52, 62, 72, 82, 92}, {3, 13, 23, 33, 43, 53, 63, 73, 83, 93}, {4, 14, 24, 34, 44, 54, 64, 74, 84, 94} };
Est équivalent à :
Code:

1 2 3 4 5 6 7 int t[][10] = { {0, 10, 20, 30, 40, 50, 60, 70, 80, 90}, {1, 11, 21, 31, 41, 51, 61, 71, 81, 91}, {2, 12, 22, 32, 42, 52, 62, 72, 82, 92}, {3, 13, 23, 33, 43, 53, 63, 73, 83, 93}, {4, 14, 24, 34, 44, 54, 64, 74, 84, 94} };
L'initialisation d'un tableau peut être icomplète dans ce cas les autres éléments sont tous initialisés à zéro. Par exemple :

Code:

int t[10] = {0, 10, 20, 30, 40};

14/01/2008, 12h17
fremen167
En résumé, on a, il me semble, deux situations :
- on connaît les dimensions du tableau : autant le définir proprement avec par exemple :
Code:

1 2 int MonTableau[5][10] /* et éventuellement ={...} */
- on ne connaît pas les dimensions : on va utiliser des tableaux dynamiques, et donc par définition on ne peut pas initialiser le tableau lors de sa déclaration.

Essayer de mélanger les deux n'a guère de sens.