Why sizeof(param_array) is the size of pointer?

Question

I want to get the length of an array, say int array[] = {1, 2, 3, 4}. I used sizeof to do that.

int length(int array[])
{
     return sizeof(array) / sizeof(int);
}

int main()
{
    int array[] = {1, 2, 3, 4};
    printf("%d\n", length(array)); // print 1
    printf("%d\n", sizeof(array) / sizeof(int)); // print 4
}

So, why the sizeof(array) in function length returns the pointer size of array? But in function main, it works.

And, how should I modify the length function to get an array's length?

Answer 1

A special C rule says that for function parameters, array types are adjusted to pointer types. That means:

int length(int array[]);

is equivalent to

int length(int *array);

So when you compute the sizeof the array you are actually computing the size of the pointer.

(C99, 6.7.5.3p7) "A declaration of a parameter as "array of type" shall be adjusted to "qualified pointer to type", where the type qualifiers (if any) are those specified within the [ and ] of the array type derivation."

Answer 2

The array decays into a pointer when you pass it into a function.

Answer 3

As the other answerers have noted, a function declared to take an array is compiled the same as if it took a pointer.

The most common way I've seen to do your length method is with a #define, but if you play tricks with templates, you can make your function work.

template <size_t _Size> inline int length(int(& array)[_Size])
{
    //return sizeof(array) / sizeof(int);
    return _Size;
};

int array[] = {1, 2, 3, 4};
printf("%d\n", length(array)); // print 4

With your array of length 4, this gets compiled as a method that takes an array of length 4, and returns a static 4. This also has the advantage that if you try to pass something that isn't an array, the compiler will give an error, whereas the #define method doesn't.

int* foo = array;
printf("%d\n", length(foo)); 
    // error C2784: 'int length(int (&)[_Size])' : could not deduce template
    //     argument for 'int (&)[_Size]' from 'int *'
    // test.cpp(56) : see declaration of 'length'

Answer 4

In the main program, the compiler knows the length of the array. In the subroutine, it doesn't. In particular, in a subroutine, a parameter of type int[] is identical to a parameter of type int *. In the main program, on the other hand, array has type int[4]. (You can test this by trying to assign another value to array in side main. The compiler will complain.)

Answer 5

C does not store runtime metadata about the size of an array with the variable. You will have to store that yourself somewhere.

A variable of type int[] in the context of your method length is just a pointer to a block of memory. That's why the size is the same as the size of any other pointer on your system.

When sizeof has access to the array at compile-time (as in your main function) it will instead return the number of bytes occupied by the array.

Answer 6

If you want length to be aware of the true size of the passed in array, that information has to be passed in, as everyone says. But it is possible for it to receive a reference to the array with the information also built-in:

int length(int n, int (* array)[n])
{
     return sizeof(*array) / sizeof(int);
}

int main()
{
    int array[] = {1, 2, 3, 4};
    printf("%d\n", length(4, &array)); // print 1
    printf("%d\n", sizeof(array) / sizeof(int)); // print 4
}

I don't know what good that actually does you, though, since the size is already provided in the first place. But you see that the sizeof operator works as you wanted it to in this case.

Answer 7

Because the variable array inside length is not the same as the one outside. You have to keep the sizeof(array) / sizeof(int) in the main function.

Answer 8

To modify your code so that length can get the array's length, turn it into a macro:

#define length(x) (sizeof(x)/sizeof(*x))

For your code sample, this will behave as you expect.

Note that this will only work on statically-allocated arrays, and only when called using the original array (it won't work when using a pointer to the array). This is because when you write sizeof(x) where x is a pointer to an array, the compiler interprets it literally. It doesn't have any way of mapping x back to the array that it points to before evaluating the sizeof.