I wrote an array_length function like this:
int array_length(int a[]){
return sizeof(a)/sizeof(int);
}
However it is returning 2 when I did
unsigned int len = array_length(arr);
printf ("%i" , len);
where I have
int arr[] = {3,4,5,6,1,7,2};
int * parr = arr;
But when I just do
int k = sizeof(arr)/sizeof(int);
printf("%i", k);
in the main function, it returns 7.
What is the correct way to write the array_length function and how do I use it?
Computing array lengths, in C, is problematic at best.
The issue with your code above, is that when you do:
int array_length(int a[]){
return sizeof(a)/sizeof(int);
}
You're really just passing in a pointer as "a", so sizeof(a) is sizeof(int*). If you're on a 64bit system, you'll always get 2 for sizeof(a)/sizeof(int) inside of the function, since the pointer will be 64bits.
You can (potentially) do this as a macro instead of a function, but that has it's own issues... (It completely inlines this, so you get the same behavior as your int k =... block, though.)
Use a macro...
#define SIZEOF_ARRAY( arr ) sizeof( arr ) / sizeof( arr[0] )
It'll also have the bonus of working for any array data type :)
In general, it is impossible to measure array size C. In your main function, the compiler counts the elements you wrote between the braces for you, so you're really declaring int arr[7]. That has the size you expect.
In your function, however, int a[] is equivalent to int *a -- a pointer to an integer. You know it's an array, so there are more integers following, but your array_length function could be passed any integer pointer, so it can't know.
This is one of the many reasons to use std::vector instead of raw arrays whenever possible.
try _countof it's defined in WinNT.h as
// Return the number of elements in a statically sized array.
// DWORD Buffer[100];
// RTL_NUMBER_OF(Buffer) == 100
// This is also popularly known as: NUMBER_OF, ARRSIZE, _countof, NELEM, etc.
//
#define RTL_NUMBER_OF_V1(A) (sizeof(A)/sizeof((A)[0]))
Your function won't work. C arrays and C pointers are different types, but the array will degenerate into a pointer if you look at it funny.
In this case, you're passing the array as a parameter, and it's turning into a pointer in the call, so you're measuring the sizeof(int *)/sizeof(int).
The only way to make this work is to use a macro:
#define ARRAYSIZE(x) (sizeof(x)/sizeof(*x))
and that will only work if x is declared in that scope as an array and not as a pointer.
The general procedure for computing the number of elements in an array is sizeof arr / sizeof arr[0] (or sizeof arr / sizeof *arr). Having said that...
Writing a function to compute the length of an array passed as an argument is doomed to failure, because what the function receives is a pointer, not an array. When you call your function with an array expression as the argument, the array expression will have its type implicitly converted from "array of T" to "pointer to T" and its value will be set to point to the first element in the array. Your function doesn't see an array object; it sees a pointer.
In the context of a function parameter declaration, int a[] is exactly the same as int *a, but that's only true for function parameter declarations (nothing would make me happier than to see the first form banished from all future versions of C, but that's not going to happen).
Array reference will solve this, although I'd never suggest using such a thing (since it will only work if you either always pass by ref, or use it in the scope in which the array has been defined):
#include <iostream>
template <typename Arrtype>
unsigned mysize (Arrtype (&arr)) {
return sizeof(arr) / sizeof(arr[0]);
}
int main () {
unsigned arr[13];
std::cout << mysize(arr) << std::endl; // prints 13
}
Also mentioned here: http://cplusplus.co.il/2009/09/06/more-on-arrays/
Edit: As suggested in the comments, another possible solution is this:
template <typename T, unsigned N>
unsigned mysize(T (&)[N]) {
return N;
}
The problem is that function parameters can't really be arrays, even though C lets you make a declaration that looks like one. The parameter ends up being a simple pointer. I've said elsewhere:
This boils down to the fact that plain array parameters in C/C++ are a fiction - they're really pointers. Array parameters should be avoided as much as possible - they really just confuse matters.
That's why this type of construct to return the number of elements in an array ends up being a macro in C. See this previous SO answer for what I think is a good (if complicated) implementation of the macro:
For ease of reference, here's the macro:
#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
The complications in that macro make it safer to use than most (note that I don't claim to be the originator of the techniques used in the macro).
The simple answer to your question is: there is no way to write the array_length function. You might be able to get away with a macro definition, but that depends upon the context in which you will use the macro.
You have made the common mistake of confusing arrays and pointers in C. In C, an array's name, in most cases, is equivalent to a pointer to its first element. Your array_length function receives an array a in such a context. In other words, it is impossible to pass an array as an array in C. You function is as if it is defined like this:
int array_length(int *a){
return sizeof(a)/sizeof (int);
}
which, basically divides the size of int * by the size of int. Also, by the above description, it is impossible to know the size of an array in C in a function.
Now, how can you determine its size properly outside of the function? The answer is that sizeof operator is one of the cases where the name of an array does not reduce to a pointer to its first element. I have explained the differences more elaborately in this answer. Also note that despite appearances, sizeof is an operator, not a function (as we just learned, it can't be a function, because then it won't be able to calculate the size of an array).
Finally, to determine the size of an array a of any type T, I prefer:
size_t sz = sizeof a / sizeof a[0];
The above is type-agnostic: a could be of any type above. Indeed, you could even change the type of a and would not need to change the above.
int arr[whatever] inside function argument list defines a pointer, not an array. Hence, the information about length is lost forever.
why!?
To see why, you must understand what C is all about. C never copies complex chunks around implicitly. So when you say "pass me an array" it actually means "I want to pass an address, which array's name usually is".
This is not a disadvantage. If you want more, you will have to pass it manually. The reward is that you know exactly what's going on on machine's level, giving you performance and other benefits. This is how you can have one universal programming language for all purposes.
The "int a[]" syntax used as a function argument is equivalent to "int *a".
This syntax:
int arr[] = {3,4,5,6,1,7,2};
Only works at compile time.
So while you can write: int arr[] = {3,4,5,6,1,7,2}; printf("size=%d\n", sizeof(arr));
This will only work at compile time.
One way you could get around this is to make the arrays dynamic and create your own array type.
e.g.
typedef struct array{
int length;
int *arr;
} array;
And use malloc to set it's size. You could populate it using the elipses.
populate_array(array, ...);
e.g. then calling populate_array(arr, 1,2,3,4,5,6); see stdarg.
However, since your C compiler is quite possibly a C++ compiler too. Think about using std::vector instead. The hard work is then done for you.
there is no way to determine the size of an array passed into a function like this
void foo(int a[]);
there is not enough information at compile time or at run time to work it out
The sizeof tricks only work in source locations where the array size is specified