Discussion :

[Rhyos]

Bonjour a tous,

j'ai des questions sur les pointeurs et les tableaux multi dimension, et j'ai cherché déjà sur plusieurs forums, et je crois que cela m'a perdu encore plus qu'avant

j'ai une question simple, mais je n'ai pas trouvé de reponse claire encore...

j'aimerai par exemple écrire (en C) une fonction générique qui affiche une matrice :

Code :

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

void display(double **array, int dimx, int dimy)

et si je veux la tester, je cree une matrice de test comme ca :

Code :

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

double A[2][3] = {{0 ,1 ,2}, {3, 4, 5}};

et la je ne sais pas comment passer ma matrice à ma fonction

je sais que si je mets ca, ca ne marche pas :

Code :

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

1
2
3
4
 
display(A); // a priori ca serait l'adresse du premier élément de A?
display(&A[0][0]); // autre formulation de l'adresse du 1er elt ?
display(&A[0]);

Je ne suis pas sur, peut-etre est-ce du a une confusion entre C et C++, mais je ne sais pas trop si

Code :

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

1
2
3
A[i][j] = *( *(A+i) +j)
ou si 
A[i][j] = *( A+i*dimx +j)

je sais qu'un raisonnement de ce type fonctionnerait avec des tableaux de taille 1, on peut ecrire

Code :

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

1
2
3
4
 
void display(double *array1D, int dim);
double A[3] = {0 ,1 ,2};
display(A,3);

mais qu'est-ce qui change quand on passe en dimension superieure ?
Autrement dit quel est le type de A dans :

Code :

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

double A[2][3] = {{0 ,1 ,2}, {3, 4, 5}};

????
enfin du coup comment je peux créer un prorotype de fonction en C pour afficher A, qqchose qui me permettre de faire :

Code :

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

1
2
3
4
double A[2][3] = {{0 ,1 ,2}, {3, 4, 5}};
double B[2][2] = {{0 ,1}, {3, 4}}
display(A,2,3);
display(B,2,2);

j'imagine que ma question a été posée moulte fois, mais a ce que j'ai compris (ou pas compris plutôt...) il y a des différences d’interprétation par le compilateur suivant qu'on est en C ou en C++, et je suis complètement perdu la....

merci beaucoup pour votre aide a tous ^^

[ternel]

J'ai pas tout saisi, mais je peux te rappeler la base du problème, les règles de typage en C ou C++.

int[] et int* sont deux types équivalent à de nombreux égards.
Le nom d'un tableau est l'adresse de son premier élément.

Je lis int A[][] comme "A[][] est un int", ce qui implique "A[] est un int*" et "A est un int**".

du coup, si f(int**) est déclarée, f(A) me semble être un appel légitime.

[Rhyos]

bha justement non, c'est ce que je croyais aussi, mais par exemple concrètement dans mon code, j'ai une structure :

Code :

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

1
2
3
4
5
6
7
8
9
10
typedef struct mip{
    double ** _A;
    int dimx;
    int dimy;
} MIP;
 
mip _A;
double A[4][3] = {{1 , 2 , -1},{4 , 0 , -1},{6 , -2 , -1},{1 , 2 , -1}};
mip._A = A;
[...]

j'obtiens :

Code :

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

warning: assignment from incompatible pointer type

correspondant a la ligne de mip._A = A, avec un

Code :

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

zsh: 8576 segmentation fault (core dumped)

plus loin dans l’exécution, je ne sais pas trop si c'est lié mais vu le pb des pointeurs, ça serait possible...


je viens aussi de faire un test supplementaire, en faisant

Code :

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

1
2
3
printf("A=%p, *A=%p",A,*A);
j'obtiens :
A=0x7fff06059300, *A=0x7fff06059300

je suis encore plus que perdu !!!

[Bktero]

Et depuis quand on copie un tableau (quelque soit son nombre de dimensions) avec un simple = ?

De plus, le code ne compile pas chez moi.

[Rhyos]

Et depuis quand on copie un tableau (quelque soit son nombre de dimensions) avec un simple = ?

nan mais si on manipule des pointeurs, ca doit etre possible non ?
au pire, on peut faire une fonction de copie de contenu, mais alors le probleme est le meme quel est le prototype de la fonction de copie ?

Code :

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

1
2
void copie(double **origine, double** dest, int dimx, int dimy) ??
copie(A,_A); //va donner aussi le warning du warning: assignment from incompatible pointer type...

dites moi si je susi en train de me noyer dans une flaque d'eau

[Rhyos]

De plus, le code ne compile pas chez moi.

jsutement, j'aimerai bien comprendre pourquoi il ne compile pas

pourquoi A** n'est pas un equivalent de A[][] ??

[diogene]

jsutement, j'aimerai bien comprendre pourquoi il ne compile pas

pourquoi A** n'est pas un equivalent de A[][] ??

Bien sûr que ce n'est pas la même chose, pas plus que A* n'est la même chose que A[].

Pour comprendre, il suffit de connaître cette unique règle :

- Si E est une expression dont l'évaluation désigne un tableau d'élements T, alors le résultat de l'évaluation de l'expression E est le tableau seulement dans deux cas
-- E est opérande de sizeof
-- E est opérande de l'opérateur (unaire) & (adresse de)
- Dans tous les autres cas, le résultat de l'évaluation de l'expression E est l'adresse du premier élément du tableau et est donc du type T*

Donc, soit un tableau double A[2][3] à passer en argument d'une fonction f : f(A,.....)
- Le tableau A est un tableau de 2 tableaux de 3 double.
- Le type des éléments de A est alors "tableau de 3 double" : double [3].
- Le paramètre correspondant doit être du type "adresse d'un élément du tableau A" donc "adresse d'un tableau de 3 double" : double (*)[3]
- On doit donc avoir pour prototype de la fonction ...f(double (*tab)[3],....)

Avec un paramètre du type ...g(double **tab,....), l'argument doit être l'adresse d'un pointeur sur double. Il sera utilisé pour un tableau de pointeurs sur double:
double * B[2]; g(B,....)

[Jean-Marc.Bourguet]

int[] et int* sont deux types équivalent à de nombreux égards.
Le nom d'un tableau est l'adresse de son premier élément.

NON !

Un tableau est un tableau (et n'a pas necessairement un nom). Un pointeur est un pointeur. Les deux sont des choses bien differentes. Le C a tendence a permettre de la confusion parce que:

• dans la plupart des contextes, un tableau -- qu'il soit nomme ou non -- est converti implicitement en un pointeur vers son premier element;
• dans les prototypes de fonction, la syntaxe des tableaux permet parfois de declarer un pointeur.

Une fonction ne peut prendre comme parametre un tableau. On contourne en passant un pointeur vers le premier element, ce qui est facilite par la conversion implicite dont j'ai parle.

Les tableaux bidimentionnels n'existent pas en C. On contourne en utilisant des tableaux de tableaux (il y a des langages qui ont les deux, ca apporte son lot de confusion aussi). Si on veut passer un tableau bidimentionnel, donc un tableau de tableaux, a une fonction, on passe un pointeur vers le premier element du tableau, qui lui meme est un tableau. Donc

Code :

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

1
2
3
4
5
6
7
8
 
void display(double (*array)[dimy], int dimx);
void display(double array[][dimy], int dimx); // valable aussi a cause du deuxieme point, mais pourquoi augmenter la confusion en utilisant ca?
 
...
double tab[dimx][dimy];
display(tab, dimx); // equivalent a display(&tab[0]) puisque c'est un des nombreux contextes ou un tableau est converti en un pointeur vers son premier element
...

Ce qui n'est autorise que si dimy est une constante (de toute maniere, le tableau ne peut etre declare que si dimy est une constante (*)).

En passant, les deux contextes principaux ou un tableau n'est pas convertit en un pointeur vers son premier element, c'est en tant qu'argument de sizeof et de &. Avec la definition de tab ci-dessus, sizeof tab donne dimx*dimy*sizeof double et &tab est de type pointeur vers tableau de dimx tableaux de dimy double.

(*) Je sais, gcc a une extension et C99 a normalise une variante.

[Obsidian]

Hello,

NON !

Un tableau est un tableau (et n'a pas necessairement un nom). Un pointeur est un pointeur. Les deux sont des choses bien differentes.

Je crois qu'il a ajouté « à de nombreux égards » justement pour éviter qu'on lui tombe dessus de la sorte. :-)

jsutement, j'aimerai bien comprendre pourquoi il ne compile pas

pourquoi A** n'est pas un equivalent de A[][] ??

Diogène t'a donné la réponse la plus pertinente. Cependant, comme c'est une source de confusion assez fréquente, voici comment cela va se passer en pratique :

En premier lieu, un tableau n'est pas à proprement parler un « objet » à part entière, et encore moins un objet « managé ». Lorsque tu déclares un tableau tel que :

Code C :

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

    int tab[10];

… tu déclares en fait dix entiers consécutifs en mémoire (et dans l'ordre). Ni plus ni moins. Si tes entiers font 32 bits, alors tu auras réservé exactement 40 octets en mémoire. Il n'y a aucune méta-donnée supplémentaire et, surtout, il n'y a pas de variable de type « pointeur » automatiquement associée au tableau proprement dit ou autre artifice.

De la même façon, lorsque tu déclares un tableau à plusieurs dimensions, l'espace occupé correspond toujours exactement au nombre total d'éléments. Donc, si tu fais :

Code C :

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

    int tab[3][4][2];

… tu déclares une suite ordonnée de 24 entiers, soit exactement 96 octets toujours avec des entiers de 32 bits. En particulier, il ne s'agit pas d'un tableau linéaire de trois entrées qui contiendrait des pointeurs vers les sous-tableaux.

La conséquence directe de ce principe est que c'est le compilateur qui, s'appuyant sur la taille déclarée des dimensions, va calculer à chaque fois l'offset résultant pour chaque élément (ce qui n'est toutefois pas bien difficile). Aucune taille ne sera déterminée à l'exécution.

Seulement, pour cela, il faut avoir une vue sur le tableau en question : s'il se trouve dans ta fonction ou s'il est déclaré au niveau global, pas de problème, mais s'il se trouve dans la fonction d'à côté, il n'y a rien qui te permette de connaître ou transmettre automatiquement ses dimensions.

Ça veut dire également qu'il t'est impossible de passer — en soi — le tableau lui-même en argument. Ce sera donc forcément un pointeur et c'est très bien comme cela car ça évite d'engorger la pile avec des données de taille arbitraire. Passer systématiquement des tableaux de 64 kilo-octets en argument serait meurtrier non seulement au niveau de la mémoire et des débordements de pile mais aussi des ressources CPU. Même aujourd'hui ce ne serait pas propre, mais alors si tu ramènes cela en 1972, c'est des coups à mettre à genoux le programme entier. Bon il est toujours possible, cependant, de passer un tableau de taille fixe à l'intérieur d'une structure mais ça, chut ! il ne faut pas le dire. :-)

Donc, contrairement à ce qui se passe au niveau local dans un bloc d'une de tes fonctions, un argument de fonction de type « tableau » sera forcément un pointeur à part entière (une variable, donc) puisqu'il faudra lui passer son emplacement en mémoire à l'exécution.

Cependant, il est tout-à-fait possible de le déclarer comme un tableau, en précisant ses dimensions :

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
#include <stdio.h>
 
void affiche (int tab[2][3][4])
{
    int i,j,k;
 
    for (i=0;i<2;++i)
    for (j=0;j<3;++j)
    for (k=0;k<4;++k) printf ("%d,%d,%d:%d, ",i,j,k,tab[i][j][k]);
}
 
int main (void)
{
    int tab[2][3][4] = { { {  1, 2, 3, 4 }, {  5, 6, 7, 8 }, {  9,10,11,12 } },
                         { { 13,14,15,16 }, { 17,18,19,20 }, { 21,22,23,24 } } };
 
    affiche (tab);
    return 0;
}

enfin du coup comment je peux créer un prorotype de fonction en C pour afficher A, qqchose qui me permettre de faire :

Code C :

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

1
2
3
4
double A[2][3] = {{0 ,1 ,2}, {3, 4, 5}};
double B[2][2] = {{0 ,1}, {3, 4}}
display(A,2,3);
display(B,2,2);

Techniquement, c'est possible mais seulement depuis les VLA, donc avec C99. Décomposons cela en deux parties. Tu pourrais écrire d'une part :

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
#include <stdio.h>
 
void affiche (void * ptr,int x,int y,int z)
{
    if (x>0 && y>0 && z>0)
    {
        int i,j,k;
        int (*tab)[y][z] = ptr;
 
        for (i=0;i<2;++i)
        for (j=0;j<3;++j)
        for (k=0;k<4;++k) printf ("%d,%d,%d:%d, ",i,j,k,tab[i][j][k]);
    }
}
 
int main (void)
{
    int tab[2][3][4] = { { {  1, 2, 3, 4 }, {  5, 6, 7, 8 }, {  9,10,11,12 } },
                         { { 13,14,15,16 }, { 17,18,19,20 }, { 21,22,23,24 } } };
 
    affiche (tab,2,3,4);
    return 0;
}

… et comme il ne s'agit que d'un pointeur, tu as la possibilité de le déclarer directement dans les arguments. Mais comme la définition de cet argument dépend des autres, tu es obligé de passer « x », « y » et « z » avant la définition du 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
15
16
17
void affiche (int x,int y,int z,int tab[x][y][z])
{
    int i,j,k;
 
    for (i=0;i<2;++i)
    for (j=0;j<3;++j)
    for (k=0;k<4;++k) printf ("%d,%d,%d:%d, ",i,j,k,tab[i][j][k]);
}
 
int main (void)
{
    int tab[2][3][4] = { { {  1, 2, 3, 4 }, {  5, 6, 7, 8 }, {  9,10,11,12 } },
                         { { 13,14,15,16 }, { 17,18,19,20 }, { 21,22,23,24 } } };
 
    affiche (2,3,4,tab);
    return 0;
}

C'est expliqué notamment ici : http://nicolasj.developpez.com/articles/c99/#LIV-F

Dernière précision mais non des moindres : il faut garder à l'esprit que ce paramètre reste un pointeur, ce qui signifie que même si, syntaxiquement, tu peux l'exploiter directement comme un tableau multidimensionnel (le programme a connaissance de la taille des dimensions et est en mesure d'aller chercher les bons éléments à la bonne place), un sizeof dessus te renverra la taille d'un pointeur et pas celle du tableau, et l'opérateur « & » te renverra l'adresse de l'argument et pas celle du premier élément du tableau.

[Jean-Marc.Bourguet]

Je crois qu'il a ajouté « à de nombreux égards » justement pour éviter qu'on lui tombe dessus de la sorte. :-)

J'ai horreur de cette presentation qui simplifie legerement les cas tres simples et complique tout le reste... On ne compte plus les questions dont l'origine releve de cette confusion (en passant, s'il manque quelque chose dans la FAQ, c'est bien ca) Alors la refaire dans une question ou justement la source de confusion de l'OP est cette vision des choses, je tombe dessus sans hesitation.

[ternel]

J'ai pas tout saisi, mais je peux te rappeler la base du problème, les règles de typage en C ou C++.

int[] et int* sont deux types équivalent à de nombreux égards.
Le nom d'un tableau est l'adresse de son premier élément.

NON !
Un tableau est un tableau (et n'a pas necessairement un nom). Un pointeur est un pointeur. Les deux sont des choses bien differentes.

J'ai horreur de cette presentation qui simplifie legerement les cas tres simples et complique tout le reste... On ne compte plus les questions dont l'origine releve de cette confusion (en passant, s'il manque quelque chose dans la FAQ, c'est bien ca) Alors la refaire dans une question ou justement la source de confusion de l'OP est cette vision des choses, je tombe dessus sans hesitation.

Eh! Deux types "équivalents à de nombreux égards" ne sont pas le même type pour autant.
Mais effectivement pour tout déclaration int A[2];, A est utilisable à la place de &(A[0]).

Et si tu me donnes un exemple du contraire, j'en serai heureux. J'apprendrai quelque chose.

PS: et si je n'ai pas réagit en premier lieu, c'est pour ne pas être aggressif. Mais ce n'est pas une raison pour me tomber dessus si sèchement.

[diogene]

Mais effectivement pour tout déclaration int A[2];, A est utilisable à la place de &(A[0]).

Et si tu me donnes un exemple du contraire, j'en serai heureux. J'apprendrai quelque chose.

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
int main(void)
{
  int A[2];
  printf("%d %d\n", sizeof A, sizeof &(A[0]) );
  return 0;
}

[Bktero]

Owned !


Je pense qu'Obsidian a bien résumé : leternel avait tenté de couvrir ses arrières, mais comme ce sujet exigeait de ne pas faire de d'approximation, JMB ne pouvait pas être d'accord. Allez, tout le monde va bien

[ternel]

Bon, j'ai plus qu'à me replonger dans la passionnante lecture de la norme…
J'ai du rater un passage ou deux.

Merci de votre vigilance.