Why Do Multidimensional Arrays Decay to Pointers Differently Than Single-Dimensional Arrays?

Why Arrays Decay into Pointers Differently Depending on Dimensionality

Introduction

When working with arrays and pointers, it's important to understand how type-decay occurs. While you may expect two-dimensional arrays to decay into double pointers, this isn't always the case. Let's delve into why this happens and explore the difference in behavior.

Decay for One-Dimensional Arrays

As the test case demonstrates, one-dimensional arrays indeed decay into single pointers:

<code class="cpp">std::is_same<int*, std::decay<int[]>::type>::value; // true</code>

This is because pointer arithmetic can be performed with a single pointer.

Decay for Multi-Dimensional Arrays

However, two-dimensional arrays don't decay into double pointers:

<code class="cpp">std::is_same<int**, std::decay<int[][1]>::type>::value; // false</code>

The reason is that double pointers require additional information about the dimensions of the array. For instance, in the case of int[5][4], the compiler knows that each "inner" array has a length of 4. Casting to int (*)[4] retains this information, making pointer arithmetic possible.

However, casting to int ** loses this dimension information. It becomes simply a pointer to a pointer, which isn't enough to perform meaningful pointer arithmetic.

Understanding the Difference

Consider the following:

<code class="cpp">char *tmp = (char *)p           // Work in units of bytes (char)
          + i * sizeof(int[4])  // Offset for outer dimension (int[4] is a type)
          + j * sizeof(int);    // Offset for inner dimension
int a = *(int *)tmp;            // Back to the contained type, and dereference</code>

This code manually performs array access, demonstrating that the compiler relies on dimension information. int** doesn't provide this information, making it unsuitable for pointer arithmetic.

Conclusion

While one-dimensional arrays decay into single pointers, multi-dimensional arrays do not decay into double pointers because they lack the necessary dimension information. This behavior ensures that meaningful pointer arithmetic remains possible with single-dimension pointers.

The above is the detailed content of Why Do Multidimensional Arrays Decay to Pointers Differently Than Single-Dimensional Arrays?. For more information, please follow other related articles on the PHP Chinese website!