Arguments in a function prototype

Question

Hi. My question is: when i write a function prototype in C like this:

void foo(int *vector);

It's the same thing to do:

void foo(int vector[MAX_LENGTH]);

To the function, is passed always as a pointer? The code it's the same? Thanks in advance.

Answer 1

there's little else it could pass! the [] contraint lets the compiler do more checks though.

Answer 2

Yes an array type is implicitly converted to a pointer type when passed to a function.

So

void foo(int *a) and void foo(int a[]) are identical.

You can easily check that using sizeof() operator inside the function definition

For example

void foo(int a[])
{
   std::cout<<sizeof(a); //prints sizeof(int*)
}

int main()
{

   int a[]={1,2,3,4};
   foo(a);
}

EXTRA (Printing size of an array inside a funtion)

[C++ Only]

 template<typename T,size_t n>
 void size_of_array(T (&a)[n]) //Array passed by reference. Template argument deduction 
 {
    std::cout<<sizeof(a); //prints sizeof(n*sizeof(int))
 }

 int main()
 {
      int a[]={1,2,3,4,5};
      size_of_array(a);
 }

Answer 3

This is subtle. Arrays in C are not pointers, but C does not allow arrays to be passed as function parameters. So when you have void foo(int vector[MAX_LENGTH]);, essentially all you're doing is telling other programmers (and your future self) that this function expects an array of MAX_LENGTH to be passed to it. The compiler won't help you. It will silently cast your array to a pointer.

This explains it pretty well.

Answer 4

This is one of the rough edges of the C language(s). Two declaration that look exactly the same (but for the names), one in the prototype and one as a stack variable, result in the declaration of two different types of variables.

void foo(int A[10]) {
   int B[10];    
}

Inside the scope of foo, A is pointer to int and B is array of ten elements of type int. As somebody else mentioned, even their sizes computed with sizeof are different.

C++ inherited the rule, so for your example code the prototypes of both functions should be the same.

C99 complicates this matter even further by introducing the new keyword static ;-)

void foo(int A[static 10]) {
   int B[10];    
}

this doesn't change the rules on how A and B are seen from the inside, but provides an information to the caller side of howmuch array elements are expected. For the moment gcc accepts this new syntax and simply ignores this information.