cómo interpreta el compilador el cálculo de &a[0]+1 y &a+1

#include<stdio.h>
int main(){
    int a[5] = {0,1,2,3,4};
    int * ptr;
    ptr =(int *) &a;
    printf("\n&a:%u,&a[0]:%u,ptr:%u\n",&a,&a[0],ptr);
    ptr = (int*)(&a+1);
    printf("\n&a:%u,&a[0]:%u,ptr:%u\n",&a,&a[0],ptr);
    ptr = (int*)(&a);
    ptr = (int*)(&a[0]+4);
    printf("\n&a:%u,&a[0]:%u,ptr:%u,*ptr:%d\n",&a,&a[0],ptr,*ptr);
    return 0;
}

o / p:

&a:3213284540,&a[0]:3213284540,ptr:3213284540

&a:3213284540,&a[0]:3213284540,ptr:3213284560

&a:3213284540,&a[0]:3213284540,ptr:3213284556,*ptr:4

En el código anterior &a y &a[0] da la misma dirección 3213284540. Pero los dos casos cuando se suman con 1 da una dirección diferente.

&a[0]+1 => 3213284540 + 4     = 3213284544   [The value stored in this address is '1']
&a+1    => 3213284540 + (5*4) = 3213284560   [Goes Out of bounds of the array] 

&a+1 is equivalent to sizeof(array)+1. 

Pero cómo el compilador interpreta esto &a[0]+1 y &a+1 ?

preguntado el 13 de septiembre de 12 a las 06:09

1 Respuestas

Pero cómo interpreta el compilador esto &a[0]+1 y &a+1

Es aritmética de punteros, por lo que siempre es importante conocer los tipos puntiagudos y una cosa básica: sumar 1 a un puntero hace que apunte a algún elemento "siguiente".

  • En tu ejemplo &a[0] es de tipo int * entonces sumando 1 mueve el puntero al siguiente int. Entonces, la dirección debería aumentar en 4/8 bytes más o menos, dependiendo de sizeof(int)

  • Sin embargo, &a es de tipo int (*)[5]. Entonces sumarle 1 mueve el puntero a la siguiente matriz. En efecto, la dirección debería aumentar en sizeof(a).


Nota al margen: use %p al imprimir valores de puntero.

Respondido el 13 de Septiembre de 12 a las 06:09

Esperaba insistir en alguien por no saber que tomar la dirección de una matriz da como resultado un puntero a una matriz de... pero me decepcionó :D. +1 - Ed s.

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.