Sizeof array passed as parameter

Question

Given the following program

#include <iostream>

using namespace std;

void foo( char a[100] )
{
  cout << "foo() " << sizeof( a ) << endl;
}

int main()
{
  char bar[100] = { 0 };
  cout << "main() " << sizeof( bar ) << endl;
  foo( bar );
  return 0;
}

outputs

main() 100
foo() 4

The questions:

1. Why is the array passed as a pointer to the first element ?
2. Is it a heritage from C ?
3. What does the standard say ?
4. Why is the strict type-safety of C++ dropped ?

Answer 1

Yes. In C and C++ you cannot pass arrays to functions. That's just the way it is.

Why are you doing plain arrays anyway? Have you looked at boost/std::tr1::array or std::vector?

Note that you can, however, pass a reference to an array of arbitrary length to a function template. Off the top of my head:

template< std::size_t N >
void f(char (&arr)[N])
{
  std::cout << sizeof(arr) << '\n';
}

Answer 2

Yes its a heritage from C. The function:

void foo ( char a[100] );

Will have the parameter decay to a pointer, and so becomes:

void foo ( char * a );

If you want that the array type is preserved, you should pass in a reference to the array:

void foo ( char (&a)[100] );

C++ '03 8.3.5/3:

...The type of a function is determined using the following rules. The type of each parameter is determined from its own decl-specifier-seq and declarator. After determining the type of each parameter, any parameter of type "array of T" or "function returning T" is adjusted to be "pointer to T" or "pointer to function returning T," respectively....

To explain the syntax:

Check for "right-left" rule in google, I found one description of it here.

It would be applied to this example approximately as follows:

void foo (char (&a)[100]);

Start at identifier 'a'

'a' is a

Move right - we find a ) so we reverse direction looking for the (. As we move left we pass &

'a' is a reference

After the & we reach the opening ( so we reverse again and look right. We now see [100]

'a' is a reference to an array of 100

And we reverse direction again until we reach char:

'a' is a reference to an array of 100 chars