Sizeof of an array...how does it work?

Question

Watch here:

int main(void){
 int array[10];
 printf("%d",sizeof(array));
}

In this case, it shows 40, but how does sizeof work?
'array' is only an address, how does it determinate the size with only an address?

---EDIT---
I badly explained myself... I know that an array is not an address, but the word array used in this program equates to an address

Answer 1

'array' is only an address

It is not. You believe some false things about arrays.

An array is not an address. An array may be used in a context that expects the address of an array element.

I can use orange peels in a recipe that calls for lemon peels; that does not mean that oranges are lemons.

how does it determinate the size with only an address?

It does not.

array is an array of ten four-byte integers. The compiler knows that. Your program is equivalent to printf("%zu",10 * sizeof int);.

(Pedantic note: sizeof gives the size in chars. It just so happens that the vast majority of the time, a char is one byte.)

In C99 it is legal to say:

int n = whatever();
int b[n + 10];
printf("%zu\n", sizeof b);

and sure enough this will print out (n + 10) * sizeof int.

How on earth does it do this?

Beats the heck out of me. Find the source code for a C99 compiler and see what it does. But first think: if you had to write a compiler that had that property, what would you do?

Finally, pop quiz: what does this program do?

int main(void){
 int array[10];
 int *pi = array;
 printf("%zu\n", sizeof array);
 printf("%zu\n", sizeof pi);
}

Answer 2

sizeof gives you the size of the array in chars (which are 1 byte long on most systems).

Each int is 4 chars long on your system, so to get the size in number of elements of the array, try:

sizeof(array) / sizeof(int)

Keep in mind that this will only work for arrays that are allocated statically. For arrays that are dynamically allocated (i.e. using malloc), you'll have to keep the length of the array safe elsewhere, or otherwise have some magic value at the end of the array that will let you iteratively find the size of the array (by looping through it until you get to the magic value). A common "magic value" is NULL.

Sizeof uses the typename of the symbol provided to it (or the type provided to it) in order to determine size. An int varname[10] takes sizeof(int) * 10 chars. If you were to use

int *varname = (int*)malloc(sizeof(int) * 10));

then, sizeof(varname) would give you the same result as sizeof(int *), which is (in most cases) either 4 or 8, depending on whether you are on a 32 bit or 64 bit system.

Note that when using an initializer for an array:

int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

Then sizeof(array) will return the same value as it would were it run on:

int array[10];

This is because C would know the size of the array at compile time, and infer the type of array to be an array of 10 ints in both cases.

Answer 3

Arrays are a distinct type. They convert to pointers to their first element inside of arithmetic expressions and in function calls, however a sizeof expression is neither.

sizeof is an operator (sizeof array (without the parens) works too) and that operator gets access to the real type of the variable, which is int[10] ( whose size is sizeof(int) * 10 ).

By the way, the type of the value of a sizeof is size_t so you need to print it with %zu, not %d.

Answer 4

When the compiler produces an executable, it determines the size and puts that directly into the code to be run. Note that sizeof(int) on different platforms can be different).

The run-time executable code ends up working like this:

#define SIZEOF_INT (4)
#define SIZEOF_ARRAY (4*SIZEOF_INT)
int main(void){
 int array[10];
 printf("%d",SIZEOF_ARRAY /*compiler replaces sizeof(array) here */);
}

'array' is still an address at run-time (within the executable). But sizeof(array) gets changed to a number equivalent to the size at run-time.

Answer 5

Please check this link that contains the explanation you're looking for and this will help you solve your issue. by Mark Harrison.

How do I determine the size of my array in C?

To determine the number of elements in the array, we can divide the total size of the array by the size of the array element. You could do this with the type, like this:

int a[17];
int n = sizeof(a) / sizeof(int);
and get the proper answer (68 / 4 = 17), but if the type of a changed you would have a nasty bug if you forgot to change the sizeof(int) as well.

So the preferred divisor is sizeof(a[0]), the size of the zeroeth element of the array.

int a[17];
int n = sizeof(a) / sizeof(a[0]);