¿Cómo determina “sizeof” el tamaño de una matriz?

¿Cómo encuentra C el tamaño de una matriz en tiempo de ejecución? ¿Dónde se almacena la información sobre el tamaño o los límites de la matriz?

sizeof(array) es implementado completamente por el compilador de C. En el momento en que el programa se vincula, lo que parece un sizeof() llamarte se ha convertido en una constante.

Ejemplo: cuando compila este código C:

#include <stdlib.h>
#include <stdio.h>
int main(int argc, char** argv) {
    int a[33];
    printf("%d\n", sizeof(a));
}

usted obtiene

    .file   "sz.c"
    .section        .rodata
.LC0:
    .string "%d\n"
    .text
.globl main
    .type   main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl   -4(%ecx)
    pushl   %ebp
    movl    %esp, %ebp
    pushl   %ecx
    subl    $164, %esp
    movl    $132, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    addl    $164, %esp
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size   main, .-main
    .ident  "GCC: (GNU) 4.1.2 (Gentoo 4.1.2 p1.1)"
    .section        .note.GNU-stack,"",@progbits

El $132 en el medio está el tamaño de la matriz, 132 = 4 * 33. Observe que no hay call sizeof instrucción – a diferencia de printfque es una función real.

sizeof es tiempo de compilación puro en C++ y C antes de C99. A partir de C99 hay matrices de longitud variable:

// returns n + 3
int f(int n) {
    char v[n + 3];

    // not purely a compile time construct anymore
    return sizeof v;
}

Eso evaluará la sizeof operando, porque n aún no se conoce en tiempo de compilación. Eso solo se aplica a matrices de longitud variable: otros operandos o tipos todavía hacen que el tamaño de cálculo en tiempo de compilación. En particular, las matrices con dimensiones conocidas en el momento de la compilación aún se manejan como en C++ y C89. En consecuencia, el valor devuelto por sizeof ya no es una constante de tiempo de compilación (expresión constante). No puede usarlo donde se requiere dicho valor, por ejemplo, al inicializar variables estáticas, a menos que una extensión específica del compilador lo permita (el estándar C permite que una implementación tenga extensiones a lo que trata como constante).

sizeof() solo funcionará para una matriz de tamaño fijo (que puede ser estática, basada en pilas o en una estructura).

Si lo aplica a una matriz creada con malloc (o nuevo en C++) siempre obtendrá el tamaño de un puntero.

Y sí, esto se basa en la información de tiempo de compilación.

sizeof da el tamaño de la variable, no el tamaño del objeto al que está apuntando (si hay uno). sizeof(arrayVar) devolverá el tamaño de la matriz en bytes si y solo si arrayVar se declara en el alcance como una matriz y no como un puntero.

Por ejemplo:

char myArray[10];
char* myPtr = myArray;

printf("%d\n", sizeof(myArray)) // prints 10 
printf("%d\n", sizeof(myPtr)); // prints 4 (on a 32-bit machine)

sizeof(Array) se busca en tiempo de compilación, no en tiempo de ejecución. La información no se almacena.

¿Quizás está interesado en implementar la verificación de límites? Si es así, hay varias maneras diferentes de hacerlo.