array length using pointers

Question

Array length can be calculated using *(&arr+1)-arr which then simplifies to (&arr)[1]-arr which further simplifies to 1[&arr]-arr.

But when the length is calculated in a function different from where memory allocation has been done, wrong results are computed.

For instance,

#include <iostream> 
#define ARRAY_SIZE(arr) (1[&arr]-arr)      
using namespace std;

void func(int *arr)
{
    cout<<ARRAY_SIZE(arr)<<endl;
}

int main()
{
    int arr[]={1,2,3,4,5};
    cout<<ARRAY_SIZE(arr)<<endl;
    func(arr);
}

This gives the output:

5
8

What accounts for such strange behaviour?

It's not strange if you understand how your `*(&arr+1)-arr` trick works. — R. Martinho Fernandes, Jul 30 '13 at 11:32
Is that output from the actual code you posted, or the output from some similar code using `char *` instead of `int *`? — Mats Petersson, Jul 30 '13 at 11:34
possible duplicate of [c++ - length of array inside class function](http://stackoverflow.com/questions/16618221/c-length-of-array-inside-class-function) or http://stackoverflow.com/questions/1328223/sizeof-array-passed-as-parameter — CB Bailey, Jul 30 '13 at 11:35
I am truly curious about where it is that people find this stupid way of computing array sizes when learning C++. — R. Martinho Fernandes, Jul 30 '13 at 11:38
Because most C++ tutorials are C in C++ with brief mention of classes later on tutorials. — Neil Kirk, Jul 30 '13 at 11:40
@Neil Even in C you can do better than that :( http://stackoverflow.com/a/12784339/46642 — R. Martinho Fernandes, Jul 30 '13 at 11:49
@CharlesBailey x[y]=*(x+y)=*(y+x)=y[x]. If the comment was sarcastic, i said simplifies because 2 parentheses are saved in this conversion. — sudeepdino008, Jul 30 '13 at 11:49
@R.MartinhoFernandes I wouldn't use this method for daily purposes. It was something new with an interesting mechanism. — sudeepdino008, Jul 30 '13 at 11:52
@sudeepdino008: I am surprised that you consider `1[&a]-a` simpler that `(&a + 1) - a`. But the explanation appears to be that you consider "simpler" == "fewer parentheses". — CB Bailey, Jul 30 '13 at 11:54
Simpler means easier to understand. 1[&a] is very obscure syntax that will confuse many people. — Neil Kirk, Jul 30 '13 at 13:27

Mike Seymour · Accepted Answer · 2013-07-30T13:02:33.130

5

Array length can be calculated using *(&arr+1)-arr

Only if arr is actually an array. Within func, arr is a pointer, so this dereferences a random word of memory to give undefined behavoiur.

There is no way to tell the size of an array given just a pointer to its first element. You could pass the array by reference:

template <size_t N>
void func(int (&arr)[N]) {
    cout<<ARRAY_SIZE(arr)<<endl;
    cout<<N<<endl;               // equivalent, and less weird
}

Using the same technique, we can reimplement ARRAY_SIZE without resorting to the preprocessor or any bizarre pointer arithmetic:

template <size_t N>
size_t ARRAY_SIZE(int (&arr)[N]) {
    return N;
}

edited Jul 30 '13 at 13:02

answered Jul 30 '13 at 11:34

Mike Seymour

249,747
28
448
644

In C++11, I would make that second one use a template T for the type, and make it constexpr to boot. C++03 can get the same effect (a constant expression that only works on arrays), but requires some `sizeof` [trickery](http://ideone.com/VzUndj). – Dave S Jul 30 '13 at 11:45
@DaveS In C++11 you would use `std::array` instead – nikolas Jul 30 '13 at 12:10
Actually, if `arr` is a pointer, what you get from the expression `*(&arr+1)-arr` is not its size but undefined behavior. The OP got the result of 8 which may seem a plausible value for the size of `int*`, but actually it is a mere coincidence. If the code was compiled without optimization and run on a x86, this is a very likely result because the expression `*(&arr + 1)` must have picked the caller's saved EBP. – ach Jul 30 '13 at 12:52
@AndreyChernyakhovskiy: You're right; I didn't think too hard about what that nonsense would do to a pointer. – Mike Seymour Jul 30 '13 at 13:01

score 3 · Answer 2 · answered Jul 30 '13 at 11:34

In main() the compiler knows that arr is an array of size 5 * sizeof(int). In func() all the compiler knows is that arr is a pointer to a block of memory - it has no information about how big the array is, or even that it is an array (it could just be a chunk of memory allocated via malloc(), for example).

score 3 · Answer 3 · answered Jul 30 '13 at 11:35

When you pass your array to a function, it decays to a pointer and knowledge of its size is lost. func can take an array of any size, so how the size be determined? You must either pass the size of the array as an extra parameter, or use a data structure such as std::vector or (C++11) std::array, which keep track of their size.

array length using pointers

3 Answers3

Linked