uso de operador sizeof

Question

La salida del siguiente programa

#include<stdio.h> 
int main(){ 
    int *p[10]; 
    printf("%ld %ld\n",sizeof(*p),sizeof(p)); 
} 

es

8 <--- sizeof(*p) gives size of single element in the array of int *p[10] 
80 <--- sizeof(p) gives size of whole array which is 10 * 8 in size. 

ahora ver el siguiente programa

#include<stdio.h> 
#define TOTAL_ELEMENTS (sizeof(array)/sizeof(array[0])) 
int array[] = {23,34,12,17,204,99,16}; 

    int main() 
    { 
     int d; 
     printf("sizeof(array) = %ld \n",sizeof(array)); 
     printf("sizeof(array[0]) = %ld \n",sizeof(array[0])); 
     printf("sizeof int %ld\n",sizeof(int)); 
     printf("TOTAL_ELEMENTS=%ld \n",TOTAL_ELEMENTS); 
     for(d=-1;d <= (TOTAL_ELEMENTS-2);d++) 
      printf("%d\n",array[d+1]); 

     return 0; 
    } 

se

sizeof(array) = 28 
sizeof(array[0]) = 4 <--here 
sizeof int 4 
TOTAL_ELEMENTS=7 

Lo que no puedo entender es por qué el tamaño de (matriz [0]) es diferente en ambas salidas.

Answer 1

int *p[10]; es una matriz de punteros.

*p es el primer elemento de esa matriz de punteros. Entonces es un puntero a un entero. No es un número entero.

int array[] = {23,34,12,17,204,99,16}; es una matriz de números enteros. Entonces, array[0] es el primer elemento de esa matriz. Entonces es un número entero.

El tamaño de un puntero a un número entero (*p) y un número entero (array[0]) son diferentes.

Entonces sizeof(*p) y sizeof(array[0]) son diferentes.

sizeof(p) da el tamaño de la matriz de punteros. Por lo que es: 10 x 8 = 80.
x es decir (número de elementos) (tamaño de un elemento)

sizeof(array) da el tamaño de la matriz de enteros. Por lo que es: 7 x 4 = 28.

Answer 2

En el primer caso, que ha creado una matriz de punteros a int, por lo que su tamaño es de 8, no 4.

Answer 3

En el primer ejemplo, el elemento es un puntero a int, mientras que en el segundo ejemplo, es solo int. Puede ver que el puntero tiene 8 bytes, el int solo 4 bytes.

Answer 4

En el primer ejemplo se usa el tamaño de un puntero y en el segundo el tamaño de un entero. Pueden tener diferentes tamaños, especialmente en sistemas de 64 bits.

Answer 5

array[0] tiene tipo int

*p tiene tipo int*

Esto tal vez demuestra la locura estilística de la escritura

int *p[10] ; 

en lugar de

int* p[10] ; 

donde el segundo hace que sea más claro que int * es el tipo de la matriz que se está declarando.

Answer 6

Los conjuntos de entorno de 64 bits int a 32 bits y largo y el puntero a 64 bits ..

* p es un puntero - 8 bytes
sizeof (p) -is tamaño de 10 punteros - así 80 bytes

probable es que haya máquina AMD64 - comprueba esto para detalles (incluyendo otras opciones) http://gcc.gnu.org/onlinedocs/gcc/i386-and-x86_002d64-Options.html