I've the following C++ array:
byte data[] = {0xc7, 0x05, 0x04, 0x11 ,0x45, 0x00, 0x00, 0x00, 0x00, 0x00}; How can I know how many items there are in this array?
- What do you want the answer be in the case you gave? 5 or 10?Mark Byers– Mark Byers2010-01-16 11:06:23 +00:00Commented Jan 16, 2010 at 11:06
- 10 (I hate the 15 limit on comments)Alon Gubkin– Alon Gubkin2010-01-16 11:29:29 +00:00Commented Jan 16, 2010 at 11:29
Add a comment |
3 Answers
For byte-sized elements, you can use sizeof(data).
More generally, sizeof(data)/sizeof(data[0]) will give the number of elements.
Since this issue came up in your last question, I'll clarify that this can't be used when you pass an array to a function as a parameter:
void f(byte arr[]) { //This always prints the size of a pointer, regardless of number of elements. cout << sizeof(arr); } void g() { byte data[] = {0xc7, 0x05, 0x04, 0x11 ,0x45, 0x00, 0x00, 0x00, 0x00, 0x00}; cout << sizeof(data); //prints 10 } 
3 Comments
David Rodríguez - dribeas
Note that this will only work when the array definition is being seen by the compiler (that is either the array is global or within the same function). It will fail if the array is passed as argument to a function, and it will fail silently providing an erroneous answer.
int f( char data[] ) { return sizeof(data)/sizeof(data[0]); } void caller() { char array[] = { 0 }; f(array) } will return the size of a pointer (usually 4/8) and not 1, which is the actual solution. This is because arrays decay into pointers at function calls when passed by value.
Matteo Italia
Tip: it's common to define a macro like this: #define ARRSIZE(arr) (sizeof(arr)/sizeof(*(arr))) to get the number of elements of an array whose size is known at compile time.
Georg Fritzsche
"this can't be used when you pass an array to a function" ... It can when using references.
You should really use Neil's suggestion: std::vector<byte> is a much better solution in most cases (the only more complex part is initialization, on anything else it is safer).
If not, instead of using the sizeof(array)/sizeof(array[0]), or sizeof(array) (since sizeof(byte)==1), you can use a typesafe approach with templates:
template <typename T, unsigned int N> unsigned int size_of_array( T (&)[N] ) { return N; } Or, if you need a compile time constant (and at the same time you want to make sure you do not accidentally call it on non-arrays:
template <typename T, unsigned int N> char (&static_size_of_array( T (&)[N] ))[N]; #define compile_time_size(x) (sizeof(static_size_of_array((x)))) In most cases you will not need that last solution. Both templated solutions will fail fast when a pointer is passed (instead of an array):
void f( char array[] ) // misleading name: { char array2[] = { 1, 2, 3 }; size_of_array(array2); // 3 size_of_array(array); // compile time error sizeof(array)/sizeof(array[0]); // 4/8, depending on architecture!!! } answered Jan 16, 2010 at 11:07
David Rodríguez - dribeas
209k23 gold badges304 silver badges497 bronze badges
Comments
sizeof( data); // because sizeof(byte) is 1 However, this is not a good general solution - particularly if you pass the array to functions:
void f( byte a[] ) { // number of elements in 'a' unknown here } The array decays to a pointer, so the sizeof operator will always give you the size of the pointer, not the number of elements in the array.
Instead, you should use a std::vector<byte>, which has a size() member function.
3 Comments
Georg Fritzsche
"The array decays to a pointer" ... references fix that:
template<size_t n> void f(byte (&a)[n])Georg Fritzsche
No, see e.g. here (self-plug, but fastest to find): stackoverflow.com/questions/1745942/… ... with references the full array type is preserved.