How does C find the size of an array at runtime? Where is the information about the array size or bounds stored ?
Add a comment
|
5 Answers
sizeof(array) is implemented entirely by the C compiler. By the time the program gets linked, what looks like a sizeof() call to you has been converted into a constant.
Example: when you compile this C code:
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char** argv) {
int a[33];
printf("%d\n", sizeof(a));
}
you get
.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
The $132 in the middle is the size of the array, 132 = 4 * 33. Notice that there's no call sizeof instruction - unlike printf, which is a real function.
1 Comment
Andreas Wenzel
This answer is correct for fixed-size arrays, but is wrong for variable-length arrays which exist since C99.
sizeof is pure compile time in C++ and C prior to C99. Starting with C99 there are variable length arrays:
// returns n + 3
int f(int n) {
char v[n + 3];
// not purely a compile time construct anymore
return sizeof v;
}
That will evaluate the sizeof operand, because n is not yet known at compile time. That only applies to variable length arrays: Other operands or types still make sizeof compute at compile time. In particular, arrays with dimensions known at compile time are still handled like in C++ and C89. As a consequence, the value returned by sizeof is not a compile time constant (constant expression) anymore. You can't use it where such a value is required - for example when initializing static variables, unless a compiler specific extension allows it (the C Standard allows an implementation to have extensions to what it treats as constant).
answered Mar 23, 2009 at 0:01
Johannes Schaub - litb
510k132 gold badges928 silver badges1.2k bronze badges
3 Comments
Jonathan Leffler
Good that you mention C99 VLAs. However, your answer should emphasize that even in C99, fixed size arrays have their size computed at compile time -- it is only VLAs that have their size computed at runtime. And maybe, as a consequence, you can't always use 'sizeof(array)' as a constant in C99.
Johannes Schaub - litb
ok, bed time for me now. later i will wake up and scream about all those typos in my answers :p
Kyle Strand
+1 for distinguishing between compile-time and non-compile-time evaulations of
sizeof in C99, but how is the length of a variable-length-array actually computed? Is it stored in an array descriptor or something?sizeof() will only work for a fixed size array (which can be static, stack based or in a struct).
If you apply it to an array created with malloc (or new in C++) you will always get the size of a pointer.
And yes, this is based on compile time information.
3 Comments
ysth
fixed size arrays are not necessarily stack based. C has no new operator.
Jonathan Leffler
You've forgotten about C99 VLA - variable-length arrays.
hyde
"Array" has a quite specific meaning in C type system. If you have an array (not a pointer),
sizeof should work, even if the array is in memory allocated with malloc (possible via using pointer to array instead of pointer to element).sizeof gives the size of the variable, not the size of the object that you're pointing to (if there is one.) sizeof(arrayVar) will return the array size in bytes if and only if arrayVar is declared in scope as an array and not a pointer.
For example:
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)
3 Comments
Coder
can you elaborate why the top one gives 10? is that in the stack or heap?
Dan Breslau
It doesn't matter if it's in the stack or on the heap (although, to be on the heap, it would have to be embedded in a
struct definition.) The key is that the variable myArray is declared as an array, not as a pointer. So, the compiler sees that an array of 10 characters are declared, and allocates 10 bytes of storage to hold those 10 characters.Dan Breslau
In the case of
myPtr, all the compiler sees is that a pointer is being declared; it allocates 4 bytes to hold myPtr (on a 32-bit machine), but does not allocate any storage for it to point to. Instead of having its own unique memory for storing data, myPtr starts out by pointing to the memory allocated for myArray. Does that help?sizeof(Array) is looked up at compile time, not at run time. The information is not stored.
Are you perhaps interested in implementing bounds checking? If so, there are a number of different ways to go about that.
