static array in c++ forgets its size

Answer 1

When declaring a function parameter, the following two are equivalent because an array decays to a pointer when it is passed as an argument:

int array[]
int *array;

So, you end up computing sizeof(int*) / sizeof(int), which happens to be one on your platform because their sizes are the same.

If you need the size of the array in your function, you should pass it as an argument to the function, or use a container that keeps track of the size for you.

Answer 2

becuase array is a pointer at the point where you do sizeof(array). The array never knew its size (see what happens if you try to access an element beyond its end). The compiler knew at the point where it was defined; that all

Anyway the solution you want is std::vector

Answer 3

In C, and therefore I presume in C++, any array that's passed through as a parameter is turned into a simple pointer type, which loses the size information. Since your static_class constructor gets the array from a parameter, it loses its array quality.

Answer 4

You'd be surprised, but in C++, arrays are just pointers, nothing more. The array size is not stored anywhere, and certainly it not possible to pass function arguments of variable size.

Answer 5

There's also a template option, something like this?

class static_class
{
public:
   template<int I>
   static_class(int (&array)[I])
   {
      std::cout << I << std::endl;
   } 
};

I think that'd work, anyway. sizeof(array)/sizeof(array[0]) only works in scopes where the array's definition is actually visible. In other words, your static_class constructor couldn't "see" the size of the array, all it knew was that it was getting an array of some (any) size. You could pass an array of 100 elements or four, and the function itself would get no information.

In my example, on the other hand, the template will cause one version of the function to be created for each array size that you pass in. This may or may not be desirable. Generally speaking, it's best to keep the array size somewhere handy, like:

class my_class
{
public:
   static static_class s;
   static const int array_size = 4;
   static int array[array_size];
};

Then you can pass my_class::array_size around and not have to be worried about what the compiler may or may not have visible regarding array attributes.

Answer 6

The basic problem that the other answers hint at is that arrays are not first class types in C/C++. In particular, you cannot declare functions or function types that take arrays as arguments. Now, for historical reasons lost in the depth of time, instead of just saying that declaring a function argument that is an array is an error, it was decided that the compiler should silently turn the array declaration into a pointer declaration. This has lead to no end of confusion with people declaring arrays as arguments and unexpectedly getting pointers instead.