C Programming – Does a 2D Array Decay to Pointer to Pointer

arraysc++pointers

Up till now I was pretty much sure that

int arr[4][5];

Then arr will decay to pointer to pointer.

But this link proves me wrong.

I am not sure how did I get about arr being pointer to pointer but it seemed pretty obvious to me. Because arr[i] would be a pointer, and hence arr should be a pointer to pointer.

Am I missing out on something.

Best Answer

Yep you are missing out on a lot :)

To avoid another wall of text I'll link to an answer I wrote earlier today explaining multi-dimensional arrays.

With that in mind, arr is a 1-D array with 4 elements, each of which is an array of 5 ints. When used in an expression other than &arr or sizeof arr, this decays to &arr[0]. But what is &arr[0]? It is a pointer, and importantly, an rvalue.

Since &arr[0] is a pointer, it can't decay further. (Arrays decay, pointers don't). Furthermore, it's an rvalue. Even if it could decay into a pointer, where would that pointer point? You can't point at an rvalue. (What is &(x+y) ? )

Another way of looking at it is to remember that int arr[4][5]; is a contiguous bloc of 20 ints, grouped into 4 lots of 5 within the compiler's mind, but with no special marking in memory at runtime.

If there were "double decay" then what would the int ** point to? It must point to an int * by definition. But where in memory is that int * ? There are certainly not a bunch of pointers hanging around in memory just in case this situation occurs.

Related Solutions

C Pointers – Understanding 2D Arrays and Pointers

Most of the issue was your use of an unallocated structure. You used a pointer to mystruct_t but never allocated it. The following runs for me:

#include <stdio.h>

typedef struct mystruct
{
   char*  mychar [20];
} mystruct_t;

void printvalues( char** newptr )
{
   int i;
   // note: you used an unallocated pointer in your original code
   mystruct_t fd;
   for ( i = 0; i < 3; i++ )
   {
      fd.mychar[i] = newptr[i];
      printf( "My value is %s and in struct %s\n", newptr[i], fd.mychar[i] );
   }
}

int main( int argc, char **argv )
{
   int i;
   char * abc[5] = { "123", "456", "789" };

   for ( i = 0; i < 3; i++ )
   {
      printf( "My value is %s\n", abc[i] );
   }
   printvalues( abc );
}

C Pointers – Cases Where Arrays Decay to Pointers

C 2011 6.3.2.1 3:

Except when it is the operand of the sizeof operator,… or the unary & operator, or is a string literal used to initialize an array, an expression that has type “array of type” is converted to an expression with type “pointer to type” that points to the initial element of the array object and is not an lvalue.

In other words, arrays usually decay to pointers. The standard lists the cases when they do not.

One might think that arrays act as arrays when you use them with subscripts, such as a[3]. However, what happens here is actually:

a is converted to a pointer.
The subscript operator acts on the pointer and the subscript to produce an lvalue designating the object. (In particular, a[3] is evaluated as *((a)+(3)). That is, a is converted to a pointer, 3 is added to the pointer, and the ***** operator is applied.)

Note: The C 2011 text includes “the _Alignof operator.” This was corrected in the C 2018 version of the standard, and I have elided it from the quote above. The operand of _Alignof is always a type; you cannot actually apply it to an object. So it was a mistake for the C 2011 standard to include it in 6.3.2.1 3.

Best Answer

Related Solutions

C Pointers – Understanding 2D Arrays and Pointers

C Pointers – Cases Where Arrays Decay to Pointers

Related Question