&arr vs arr and *(&arr + 1) vs (&arr + 1)

Question

You can determine the length of an array in C/C++ with the following:

int arr[5] {1,2,3,4,5};
int len = *(&arr + 1) - *&arr; //5

but i also know that

cout << "(&arr + 1): " << (&arr + 1) << endl; //0x22fe34
cout << "*(&arr + 1): " << *(&arr + 1) << endl;//0x22fe34
cout << "*&arr: " << *&arr << endl; //0x22fe20
cout << "&arr: " << &arr << endl;  //0x22fe20

which means that (&arr + 1) == *(&arr + 1) and *&arr == &arr, but if i do

int len = (&arr + 1) - &arr; //1

the result is 1, not 5. I'm totally confused here. And i think this is related to this

int arr[5] {1,2,3,4,5};
int* p = arr; 
int (*ptr)[5] = &arr; 

Here too arr == &arr, so why can't i do

int arr[5] {1,2,3,4,5};
int *p = &arr; //main.cpp|53|error: cannot convert 'int (*)[5]' to 'int*' in assignment
int (*ptr)[5] = arr; //main.cpp|56|error: cannot convert 'int [5]' to 'int (*)[5]' in assignment

Is there some c/c++ guru who can explain in plain english for me?? I think i understand conceptually, arr refers to the first element of the array whereas &arr refers to the array as a whole, but its the same address!! Is it maybe some compiler magic?

Answer 1

They do refer to the same address but they are different data types. Arithmetic on pointers gives you the number of elements of that datatype between the two pointers.

So if you take the difference between two int * you get the number of ints between them, if you take the difference between two int (*)[5] then you get the number of 5 element arrays between them.

So your original trick works by &arr + 1 being one whole array after arr as it was performed on a pointer to an array. This is then dereferenced to get you back to int* and *&arr is subtracted which is also int* after the reference and dereference.

It's much simpler to just use std::size to get the number of elements in an array or, if not use the more traditional sizeof(arr)/sizeof(arr[0]) which doesn't rely on any special tricks and is much more readable.

Answer 2

Explaining the "length trick"

int arr[5] {1,2,3,4,5};
int len = *(&arr + 1) - *&arr; //5

&arr is the address of the array, of type int(*)[5]. &arr + 1 is a one-past-the-end pointer for this array. Dereferencing it results in int[5], which is implicitly convertible to int* (array-to-pointer conversion). The result of this expression is a one-past-the-end pointer for the elements of the array, of type int*. We can subtract this from *&arr or just arr to obtain the length of the array.

// shorter version of the trick above
int len = *(&arr + 1) - arr;

Note that both versions dereference a one-past-the-end pointer, so they are undefined behavior! You're just seeing a "works on my machine" effect.

There are much more readable and correct ways to obtain the length of an array, such as:

• std::size(arr) (since C++17)
• sizeof(arr) / sizeof(*arr) (C-style, avoid if possible)

Other Questions

which means that (&arr + 1) == *(&arr + 1) and *&arr == &arr, but if i do

int len = (&arr + 1) - &arr; //1

the result is 1, not 5. I'm totally confused here.

Both of these equations would fail to compile, you cannot say that *&arr == &arr. Note that a pointer to an array and a pointer to the first element of the array represent the same address, but they are different pointers. Performing + 1 on them will take differently sized steps depending on the type of the pointer.

The result is 1 because one is a pointer to the array arr, and one is a one-past-the-end pointer to the array arr. The difference between them is obviously 1, because they're one step apart. Converting to an int* is crucial for the original trick to work.

int* p = arr; 
int (*ptr)[5] = &arr; 

Here, the first line is performing array-to-pointer conversion implicitly, and the second line is taking the address of the array. These two pointers represent the same address, but they have a different type and cannot be compared or converted between one another.

int *p = &arr;       // error
int (*ptr)[5] = arr; // error

The first line attempts to convert an int(*)[5] to an int* implicitly, which is not allowed. The second line tries to do the opposite, which is also not allowed. Once again, the original trick works because we are dereferencing the pointer to the array, which gives us an int[5], which can be converted to int*:

int (*ptr)[5] = &arr;
int *p = *ptr;