Diferentes resultados de aritmética de punteros al tomar direcciones de matriz

Progtwig:

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

Salida:

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

Espero que lo siguiente sea el resultado del progtwig anterior. Por ejemplo:

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

Pero la salida de la última statement es diferente de lo que esperaba. &x también es la dirección de la matriz. Por lo tanto, si incrementa 1, se imprimirá la dirección incrementada en 4. Pero &x+1 da la dirección incrementada en 10. ¿Por qué?

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

Encontré una explicación descriptiva aquí: http://arjunsreedharan.org/post/69303442896/the-difference-between-arr-and-arr-how-to-find

SO link: ¿Por qué arr y & arr son iguales?

En el caso 4 obtienes 0x100 + sizeof x y sizeof x es 4 * sizeof int = 4 * 4 = 16 = 0x10.

(En su sistema, sizeof int es 4).

Una cosa fácil de evaluar es:

Cualquier puntero al incremento apunta a la siguiente ubicación de memoria de su tipo base .

El tipo base de & x aquí es int (* p) [4] que es un puntero a la matriz de 4 enteros .

Por lo tanto, el siguiente puntero de este tipo apuntará a 16 bytes de distancia (suponiendo que int sea de 4 bytes) de la matriz original.

Aunque x y &x evalúan con el mismo valor de puntero, son tipos diferentes. El tipo de x después de que se desintegre en un puntero es int* mientras que el tipo de &x es int (*)[4] .

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

Por lo tanto, la diferencia numérica entre &x y &x + 1 es sizeof(int)*4 .

Se puede visualizar mejor utilizando una matriz 2D. Digamos que tienes:

 int array[2][4]; 

El diseño de memoria para la array es:

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

Si utiliza un puntero a dicha matriz,

 int (*ptr)[4] = array; 

y mira la memoria a través del puntero, se ve así:

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

Como puede ver, la diferencia entre ptr y ptr+1 es sizeof(int)*4 . Esa analogía se aplica a la diferencia entre &x y &x + 1 en su código.

Lo creas o no, el comportamiento de tu progtwig es indefinido !

&x + 1 realidad apunta a algo más allá de la matriz, como lo señala inteligentemente la respuesta de @ i486. Usted no es dueño de esa memoria. Incluso intentar asignarle un puntero es un comportamiento indefinido, y mucho menos intentar desreferenciarlo .