Geoffroy Carrier a écrit :
> Genial ! Tu aurais une "regle de recurrence" stp ? Genre pour y[i][j][k]
> pour double ***y, etc. ? (je dois avouer que j'ai du mal
> intellectuellement avec les pointeurs... mais je me soigne)
Edgar Bonet wrote:
>double y[N][M];
>y s'évalue comme un double*.
'y' est 'tableau N de tableau M de double'. S'il est évalué, c'est qu'il
se trouve comme rvalue dans une expression, et alors la règle ci-dessous
s'applique :
---
Soit la définition :
T a[N] ; /* 'a' est un tableau N d'éléments de type T */
En contexte rvalue, 'a' devient un objet de type 'pointeur vers T' et de
valeur &a[0].
---
En C, tout objet a un type et une valeur ; un tableau est composé de
plusieurs éléments ; lequel prendre comme valeur du tableau ? ; par
convention, la valeur d'un tableau est l'adresse du premier élément du
tableau. Ce glissement vers un pointeur se fait /uniquement/ quand 'a' est
utilisé comme rvalue ; autrement, le type 'tableau' existe, est valide et
s'applique.
Donc, en contexte rvalue, 'y' devient l'objet
(pointeur vers tableau M de double, &y[0]), et on peut écrire :
double (*p)[M] ; /* p est un pointeur vers tableau M de double */
p = y ;
Une figure pour N=2 et M=3 :
double y[2][3] ;
adresses mémoire de doubles : 0 1 2 3 4 5
<y[0]><y[1]>
>y[i] ne veut rien dire.
... sauf en contexte rvalue. 'y[0]' est le premier élément d'une suite de
type 'tableau 3 de double' ; à droite d'un signe '=', il devient l'objet
(pointeur vers double, &y[0][0]), et on peut écrire :
double *d ;
d = y[0] ;
>y[i][j] signifie *(y+M*i+j).
Maintenant, c'est simple :
y[i][j] = *(y[i] + j) = *(&y[i][0] + j) = *(&y[0][0] + M*i + j)
Aussi :
&y[i][j] = (y[i] + j) = (&y[i][0] + j) = (&y[0][0] + M*i + j)
-Nicolas Tripon
