Size of an Array.... in C/C++?

Question

Okay so you have and array A[]... that is passed to you in some function say with the following function prototype:

void foo(int A[]);

Okay, as you know it's kind of hard to find the size of that array without knowing some sort of ending variable or knowing the size already...

Well here is the deal though. I have seem some people figure it out on a challenge problem, and I don't understand how they did it. I wasn't able to see their source code of course, that is why I am here asking.

Does anyone know how it would even be remotely possible to find the size of that array?? Maybe something like what the free() function does in C??

What do you think of this??

template<typename E, int size>
int ArrLength(E(&)[size]){return size;}

void main()
{
    int arr[17];
    int sizeofArray = ArrLength(arr);
}

Answer 1

The signature of that function is not that of a function taking an array, but rather a pointer to int. You cannot obtain the size of the array within the function, and will have to pass it as an extra argument to the function.

If you are allowed to change the signature of the function there are different alternatives:

C/C++ (simple):

void f( int *data, int size );             // function
f( array, sizeof array/sizeof array[0] );  // caller code

C++:

template <int N>
void f( int (&array)[N] );                 // Inside f, size N embedded in type
f( array );                                // caller code

C++ (though a dispatch):

template <int N>
void f( int (&array)[N] ) {                // Dispatcher
   f( array, N );
}
void f( int *array, int size );            // Actual function, as per option 1
f( array );                                // Compiler processes the type as per 2

Answer 2

You cannot do that. Either you have a convention to signal the end of the array (e.g. that it is made of non-zero integers followed by a 0), or you transmit the size of the array (usually as an additional argument).

If you use the Boehm garbage collector (which has a lot of benefit, in particular you allocate with GC_malloc and friends but you don't care about free-ing memory explicitly), you could use the GC_size function to give you the size of a GC_malloc-ed memory zone, but standard malloc don't have this feature.

Answer 3

You're asking what we think of the following code:

template<typename E, int size>
int ArrLength(E(&)[size]){return size;}

void main()
{
    int arr[17];
    int sizeofArray = ArrLength(arr);
}

Well, void main has never been standard, neither in C nor in C++.

It's int main.

Regarding the ArrLength function, a proper implementation does not work for local types in C++98. It does work for local types by C++11 rules. But in C++11 you can write just end(a) - begin(a).

The implementation you show is not proper: it should absolutely not have int template argument. Make that a ptrdiff_t. For example, in 64-bit Windows the type int is still 32-bit.

Finally, as general advice:

• Use std::vector and std::array.

One relevant benefit of this approach is that it avoid throwing away the size information, i.e. it avoids creating the problem you're asking about. There are also many other advantages. So, try it.

Answer 4

The first element could be a count, or the last element could be a sentinel. That's about all I can think of that could work portably.

In new code, for container-agnostic code prefer passing two iterators (or pointers in C) as a much better solution than just passing a raw array. For container-specific code use the C++ containers like vector.

Answer 5

No you can't. Your prototype is equivalent to

void foo(int * A);

there is obviously no size information. Also implementation dependent tricks can't help:

• the array variable can be allocated on the stack or be static, so there is no information provided by malloc or friends
• if allocated on the heap, a user of that function is not forced to call it with the first element of an allocation.

e.g the following are valid

int B[22];
foo(B);
int * A = new int[33];
foo(A + 25);

Answer 6

This is something that I would not suggest doing, however if you know the address of the beginning of the array and the address of the next variable/structure defined, you could subtract the address. Probably not a good idea though.

Answer 7

Probably an array allocated at compile time has information on its size in the debug information of the executable. Moreover one could search in the code for all the address corresponding to compile time allocated variables and assume the size of the array is minus the difference between its starting address and the next closest starting address of any variable.

For a dinamically allocated variable it should be possible to get its size from the heap data structures.

It is hacky and system dependant, but it is still a possible solution.

Answer 8

One estimate is as follows: if you have for instance an array of ints but know that they are between (stupid example) 0..80000, the first array element that's either negative or larger than 80000 is potentially right past the end of the array.

This can sometimes work because the memory right past the end of the array (I'm assuming it was dynamically allocated) won't have been initialized by the program (and thus might contain garbage values), but might still be part of the allocated pages, depending on the size of the array. In other cases it will crash or fail to provide meaningful output.

Answer 9

All of the other answers are probably better, i.e. you either have to pass the length of the array or terminate it with a special byte sequence.

The following method is not portable, but it works for me in VS2005:

int getSizeOfArray( int* ptr )
{
   int size = 0;
   void* ptrToStruct = ptr;
   long adr = (long)ptrToStruct;
   adr = adr - 0x10;
   void* ptrToSize = (void*)adr;
   size = *(int*)ptrToSize;
   size /= sizeof(int);
   return size;
}

This is entirely dependent of the memory model of your compiler and system so, again, it is not portable. I bet there are equivalent methods for other platforms. I would never use this in a production environment, merely stating this as an alternative.

Answer 10

You can use this: int n = sizeof(A) / sizeof(A[0]);