Cas des tableaux unidimensionnels
Puisque dans la déclaration :
int t[10];
« t » est l'identificateur d'un pointeur constant, nous pouvons introduire une autre manière d'accéder à une case du tableau en utilisant l'arithmétique sur les pointeurs.
En effet, les instructions suivantes sont strictement identiques :
t[i] = 0;
*(t+i) = 0;
De la même façon : &t[i] et (t+i) fournissent la même valeur. C'est l'adresse du premier octet de la case d'indice i du tableau t.
En fait, quand nous écrivons :
t[i] = 0;
Le compilateur génère des instructions machine que l'on peut écrire comme :
*(t+ i*sizeof(int))= 0;
ce qui permet de remplir la case i à partir de son premier octet avec la valeur 0.
Les 4 octets consécutifs que l'on trouve à partir de l'adresse t+ i*sizeof(int)) sont donc initialisés.
C'est donc un décalage de i entiers à partir de l'adresse du début du tableau. Ceci est transparent pour le programmeur.
float t[3] = {1.0, 2.0 ,3.0};
/* t est l'identificateur d'un pointeur constant, dont la valeur est l'adresse du premier octet du tableau */
float * pt_sur_flottant;
/* « pt_sur_flottant » est l'identificateur d'une variable qui contient une adresse vers un flottant */
/* les deux lignes suivantes sont equivalentes */
pointeur_sur_flottant = t; // on peut affecter la valeur d'une constante à une variable
pointeur_sur_flottant = &t[0]; // c'est la même chose que l'instruction ci-dessus
/* car &*(t+0) équivanut à (t+0) donc t */
/* et les deux lignes suivantes sont aussi équivalentes */
*pointeur_sur_flottant = -273.15;
/* car c'est *t donc *(t+0) donc t[0] */
t[0] = -273.15; // c'est la façon la plus simple de procéder.
Nous avons donc 2 façons de réaliser l'accès à des cases d'un tableau "bidule" :
bidule[i] et *(bidule +i)
Mais la notation bidule[i] est beaucoup plus facile à comprendre, à lire et à écrire.
C'est donc celle qu'il faut privilégier.
