Comment fonctionne sizeof (Array)

Comment c trouve-t-il à l’exécution la taille du tableau? Où sont les informations sur la taille du tableau ou les limites du tableau stockées?

sizeof(array) est entièrement implémenté par le compilateur C. Au moment où le programme est lié, ce qui ressemble à un appel à sizeof() a été converti en une constante.

Exemple: lorsque vous comstackz ce code C:

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

vous obtenez

  .file "sz.c" .section .rodata .LC0: .ssortingng "%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 

Le $132 au milieu correspond à la taille du tableau, 132 = 4 * 33. Remarquez qu’il n’y a pas call sizeof instruction de la taille de l’ call sizeof – contrairement à printf , qui est une fonction réelle.

sizeof est un temps de compilation pur en C ++ et C avant C99. À partir de C99, il existe des tableaux de longueur variable:

 // returns n + 3 int f(int n) { char v[n + 3]; // not purely a comstack time construct anymore return sizeof v; } 

Cela évaluera la sizeof opérande, car n n’est pas encore connu à la compilation. Cela s’applique uniquement aux tableaux de longueur variable: les autres opérandes ou types font toujours calculer sizeof au moment de la compilation. En particulier, les tableaux dont les dimensions sont connues à la compilation sont toujours traités comme en C ++ et C89. Par conséquent, la valeur renvoyée par sizeof n’est plus une constante de compilation (expression constante). Vous ne pouvez pas l’utiliser si une telle valeur est requirejse – par exemple lors de l’initialisation de variables statiques, à moins qu’une extension spécifique au compilateur ne le permette (le standard C permet à une implémentation d’avoir des extensions à ce qu’elle considère constantes).

sizeof() ne fonctionnera que pour un tableau de taille fixe (qui peut être statique, basé sur une stack ou dans une structure).

Si vous l’appliquez à un tableau créé avec malloc (ou nouveau en C ++), vous obtiendrez toujours la taille d’un pointeur.

Et oui, ceci est basé sur les informations de compilation.

sizeof donne la taille de la variable, et non la taille de l’object vers lequel vous pointez (s’il y en a un) sizeof(arrayVar) renverra la taille du tableau en octets si et seulement si arrayVar est déclaré comme un tableau et non un pointeur.

Par exemple:

 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) est recherché au moment de la compilation, pas au moment de l’exécution. Les informations ne sont pas stockées.

Êtes-vous peut-être intéressé par la mise en œuvre de la vérification des limites? Si tel est le cas, il existe différentes manières d’y parvenir.