Is array-of-arrays-of-T to pointer-of-T cast a legal operation in C/C++ according to the Standards?

Question

I've read all the related clauses of the Standard, but I couldn't interpret them correctly for this particular case:

const int arr[4][2] = {};
const int *ptr1 = (const int*)arr; // Is it OK/NOK and why?
const int *ptr2 = arr[0];          // Is this the same?
const int *ptr3 = &arr[0][0];      // Same?

What does the Standard say about this cast?

UPD.

And here another related question:

int i0 = ptr1[0];
int i2 = ptr2[2];
int i7 = ptr3[7];

What does the Standard say about getting values directly from these pointers?

Answer 1

Is array-of-arrays-of-T to pointer-of-T cast a legal operation in C/C++ according to the Standards?

const int *ptr1 = (const int*)arr; // Is it OK/NOK and why?

Yes it is legal. arr will first decay to a pointer to first element i.e. const int(*)[4] which is an object pointer. const int *ptr is also an object pointer type. All object pointer types can be explicitly converted to an object pointer of a different type in C++.

However, although the cast is legal, it would not be legal to indirect through the pointer and attempt to access the pointed object due to "strict aliasing" rule. It should be OK after laundering though:

auto ptr = std::launder(reinterpret_cast<const int*>(arr));

But better to just use:

auto ptr = &arr[0][0]

Which achieves the same. It won't help with accessing elements outside of the first subarray though.

---

UPD

const int *ptr2 = arr[0];          // Is this the same?
const int *ptr3 = &arr[0][0];      // Same?

Neither of these are casts, both are well-formed and are effectively equivalent.

And here another related question:

int i0 = ptr[0];
int i2 = ptr[2];
int i7 = ptr[7];

This is undefined behaviour even with the laundering. You can only access arr[0] through the reinterpreted pointer because it is derived from the decayed pointer to first subarray. Accessing ptr[0] and ptr[1] would be fine for your ptr2 and ptr3 and my laundered example.

Answer 2

With raw arrays and structures, this is perfectly well supported, a pointer to an aggregate type is inter-convertible with a pointer to its first subobject (or in the case of unions, any direct subobject). A pointer to an array holds the address of its first element. These rules apply recursively, individually and mutually.

There is no strict-aliasing violation.

It is questionable to use pointer-arithmetic to walk outside of the first "row" into subsequent rows. Comparison between two pointers anywhere in the same full-object is however always permitted.

Where you get into trouble is with C++ smart collections, such as std::vector. There you can still take &v[0][0], but only the elements of the first vector are contiguous (and for e.g. std::list there are not even two contiguous elements).