Quelqu'un peut-il me clarifier cette idée de tableau/pointeur?

Question

Dans le but d'expliquer que les tableaux ne sont que des pointeurs (en C++) à notre classe, mon professeur nous a montré ceci :

array[5]      // en affichant cela 
*(array + 5)  // retournerait la même valeur que cela

J'ai un peu de mal à le comprendre complètement. Voici ce que je pense :

array est l'adresse du premier emplacement et donc si nous ajoutons 5 à cette adresse, nous déplaçons de 5 adresses en mémoire. L'opérateur de pointeur extrait les données de l'emplacement mémoire.

Est-ce la bonne idée ? L'idée me semble encore un peu floue et j'ai l'impression de ne pas comprendre totalement. Je pense que d'entendre quelqu'un d'autre l'expliquer pourrait m'aider à mieux comprendre. Merci d'avance !

Answer 1

Vous avez bien compris.

Les tableaux sont implicitement convertis en pointeurs. Intéressant, [] fonctionne sur les pointeurs, pas sur les tableaux.

L'opérateur de sous-script [b] est défini comme *(a + (b)). [] est utilisé comme du sucre syntaxique - c'est beaucoup plus agréable d'écrire array[5] au lieu de *(array + 5)

L'arithmétique des pointeurs avec un pointeur et un entier p + i augmente l'adresse à p de i * sizeof(*p) octets.

char* p; 
p + 5; // adresse augmentée de 5

int* p;
p + 5; // adresse augmentée de 20 car sizeof(*p) est 4

L'opérateur * effectue l'indirection. Il vous donnera ce vers quoi pointe le pointeur.

int x[2];
int* p = &x[0]; // pourrait aussi être int* p = x;
*p = 5;         // x[0] vaut maintenant 5
*(p + 1) = 10;  // x[1] vaut maintenant 10

Answer 2

Votre professeur a raison de dire que les deux expressions produiront les mêmes résultats. Votre explication me laisse penser que vous avez une bonne compréhension des mécanismes.

Il n'est pas tout à fait correct de dire qu'un tableau est la même chose qu'un pointeur. Un tableau peut très facilement être converti en pointeur, ce qui peut entraîner une certaine confusion.

Par exemple, considérez ce code :

int tableau[5];
int * pointeur = new int[5];
cout << sizeof(tableau);   // affiche 5 * sizeof(int), probablement 20
cout << sizeof(pointeur); // affiche sizeof(int*), probablement 4 sur un OS 32 bits
tableau[4] = 906;
pointeur[4] = 906;
cout << *(tableau + 4) << *(pointeur + 4); // affiche "906 906"

Answer 3

À partir des tableaux mémoire en c++ sont des sections de mémoire continue du programme. c'est pourquoi vous pouvez aller *(tableau + 5) car il est 5 devant le tableau.

Gardez également à l'esprit que les tableaux en C++ commencent à 0 donc le 6ème élément dans un tableau est tableau[5] exemple

[0] [1] [2] [3] [4] [5] Index du tableau
 1   2   3   4   5   6  Numéro de l'élément

Pour accéder à l'élément 2, vous le feriez soit

• tableau[1]
• *(tableau+1)

mais s'il vous plaît gardez à l'esprit que tableau[numéro_d'index] est la syntaxe standard pour rechercher un élément dans un tableau donc assurez-vous d'utiliser tableau[numéro_d'index] au lieu de *(tableau + numéro_d'index)

Answer 4

Oui, ce que votre professeur a dit est correct.

pour l'expliquer en détail

Considérez votre tableau,

int tableau[5]

ici, il prend 5 emplacements dans la mémoire, disons 0x00 0x04 0x08 0x0C et 0x10 0x14

En supposant qu'un entier prend 4 octets, les emplacements sont espacés de 4 octets.

dans ce cas, 'tableau' représente l'adresse de base (pointeur) du tableau, c'est-à-dire 0x00. Et le type de a serait int*. (puisque le type des éléments du tableau est un entier)

Si vous faites array+1, ce sera 0x04, puisque l'incrémentation du pointeur dépend du type du pointeur. Si le pointeur est un entier, il s'incrémentera de 4 octets. Si le type de l'entier est un caractère, le pointeur s'incrémentera d'un octet.

donc si vous faites (tableau+5) cela pointerait vers l'adresse 0x14 et

*(tableau+5)

retourne la valeur de l'emplacement 0x14 qui est la valeur du 5ème emplacement du tableau.

donc en pratique, tableau[5] est égal à *(tableau+5)

Le compilateur convertit internalement array[5] en *(array+5)

donc même si nous écrivons 5[array], cela sera converti en *(5+tableau)

Bien que cela semble étrange, c'est la raison pour laquelle 5[array] fonctionne de la même manière que tableau[5]