Résultats arithmétiques de pointeur différents lors de la prise en compte de la matrice

Question

Programme:

 #include<stdio.h>

int main(void) {
    int x[4];
    printf("%p\n", x);
    printf("%p\n", x + 1);
    printf("%p\n", &x);
    printf("%p\n", &x + 1);
}
 

Sortie:

 $ ./a.out
0xbff93510
0xbff93514
0xbff93510
0xbff93520
$
 

Je suppose que ce qui suit est la sortie du programme ci-dessus. Par exemple:

 x        // 0x100
x+1      // 0x104  Because x is an integer array
&x       // 0x100  Address of array
&x+1     // 0x104
 

Mais le résultat de la dernière déclaration est différent de ce à quoi je m'attendais. &x est également l'adresse du tableau. Donc, incrémenter 1 sur ceci affichera l'adresse incrémentée de 4. Mais &x+1 donne l'adresse incrémentée de 10. Pourquoi?

Answer 1

 x -> Points to the first element of the array.
&x ->Points to the entire array.
 

Nous sommes tombés sur une explication descriptive ici: http://arjunsreedharan.org/post/69303442896/the-difference-between-arr-and-arr-how-to-find

SO link: Pourquoi arr et & arr sont-ils les mêmes?

Answer 2

Dans le cas 4, vous obtenez 0x100 + sizeof x et sizeof x est 4 * sizeof int = 4 * 4 = 16 = 0x10.

(Sur votre système, sizeof int est égal à 4).

Answer 3

Un thumbrule facile à évaluer est:

Tout pointeur sur l'incrémentation pointe vers le prochain emplacement mémoire de son type de base .

Le type de base de & x ici est int (* p) [4], qui est un pointeur sur un tableau de 4 entiers .

Ainsi, le pointeur suivant de ce type pointera à 16 octets de distance (en supposant que int soit 4 octets) du tableau d'origine.

Answer 4

Même si x et &x correspondent à la même valeur du pointeur, ils sont de types différents. Type d' x après qu'il se désintègre à un pointeur est - int* alors que le type d' &x est int (*)[4].

sizeof(x) est sizeof(int)*4.

D'où la différence numérique entre &x et &x + 1 est sizeof(int)*4.

Il peut être mieux visualisées à l'aide d'un tableau 2D. Disons que vous avez:

int array[2][4];

La disposition de la mémoire pour array est:

array
|
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+

array[0]        array[1]
|               |
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+

Si vous utilisez un pointeur vers un tableau,

int (*ptr)[4] = array;

et regardez la mémoire à travers le pointeur, ça ressemble:

ptr             ptr+1
|               |
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+

Comme vous pouvez le voir, la différence entre ptr et ptr+1 est sizeof(int)*4. L'analogie s'applique à la différence entre &x et &x + 1 dans votre code.

Answer 5

Croyez-le ou non, le comportement de votre programme n'est pas défini !

&x + 1 pointe en fait juste au - delà du tableau, comme le souligne intelligemment la réponse de @ i486. Vous ne possédez pas cette mémoire. Même tenter d’attribuer un pointeur à ce dernier est un comportement indéfini, encore moins d’essayer de le déréférencer .