tableaux multidimension et pointeurs

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 :cry:

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:

---

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

---

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

Code:

---

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:

---

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:

---

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:

---

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:

---

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:

---

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 ^^

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.

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

Code:

---

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:

---

warning: assignment from incompatible pointer type

---

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

Code:

---

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:

---

1 2 3

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

---

je suis encore plus que perdu !!! :cry: :cry: :cry: :cry:

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

De plus, le code ne compile pas chez moi.

Citation:

---

Envoyé par Bktero

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

---

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:

---

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 :aie:

Citation:

---

Envoyé par Bktero

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[][] ??

Citation:

---

Envoyé par leternel

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:

---

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.

Citation:

---

Envoyé par Rhyos

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 :

Citation:

---

- 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,....)

merci beaucoup pour ces deux dernières réponses, enfin j'ai compris !!
C'est le jour le plus beau de ma vie !! (ou pas en fait)

mais est-ce qu'il y a une "good practice" pour manipuler des "tableaux" de n dimension de maniere generique (je veux dire sans que dans le prototype de la fonction on impose strictement la taille du tableau?)

la je fais comme ca maintenant : (c'est pas franchement joli ...)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

double A0[3] = {1 , 2 , -1}; double A1[3] = {4 , 0 , -1}; double A2[3] = {6 , -2 , -1}; double A3[3] = {1 , 2 , -1};   double * pA0 = (double *) A0; double * pA1 = (double *) A1; double * pA2 = (double *) A2; double * pA3 = (double *) A3;   double * A[4] = {pA0, pA1, pA2, pA3};   display(A,4,3);

---

et je n'ai plus d'erreurs !!! mais peut-être peut-on l’écrire mieux ?

merci encore en tout cas ;)

Une alternative est de prendre un tableau unidimentionnel et faire le calcul d'index soi-meme.

Code:

---

1 2 3 4 5 6 7 8 9

void f(double* t, int dimx, int dimy) { int i, j; for (i = 0; i < dimx; ++i) { for (j = 0; j < dimy; ++j) { t[i*dimy + j] = 42; } } }

---

ha ouais c'est pas bête du tout ca :ccool:
je crois que je vais faire ça :)

merci a tous ^^

Citation:

---

la je fais comme ca maintenant : (c'est pas franchement joli ...)

---

Cette méthode est pourtant très utilisée : construire un tableau de pointeurs. Le plus souvent (cf la FAQ), elle est utilisée avec des allocations dynamiques mais le principe est le même.

Elle permet de passer un tableau à une dimension (de pointeurs), donc de s'affranchir de ce problème de dimensions à fixer dans la déclaration du paramètre (pour un tableau à plus d'une dimension).

Le code peut d'ailleurs être plus compact :

Code:

---

1 2 3 4 5 6 7

double A[4][3] = {{1 , 2 , -1}, {4 , 0 , -1}, {6 , -2 , -1}, {1 , 2 , -1}}; double * Tab[4] = {A[0], A[1], A[2], A[3]}; // si l'initialisation est permise (A global) // sinon, passer par l'assignation // Tab[0] = A[0]; // Tab[1] = A[1]; //... display(TAB,4,3);

---

Hello,

Citation:

---

Envoyé par Jean-Marc.Bourguet

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. :-)

Citation:

---

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:

---

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:

---

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:

---

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; }

---

Citation:

---

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

Code:

---

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:

---

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:

---

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.

Citation:

---

Envoyé par Obsidian

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.

Citation:

---

Envoyé par leternel

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.

---

Citation:

---

Envoyé par Jean-Marc.Bourguet

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.

---

Citation:

---

Envoyé par Jean-Marc.Bourguet

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.

Citation:

---

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:

---

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; }

---

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 :zoubi:

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.

pour clore cette bataille :aie: , merci a vous tous en tout cas pour toutes ces precisions, enfin maintenant ce domaine est clair pour moi :)
:ccool: :ccool: :ccool: