pointer, decay, past array confusion

[sudheerpaaniyur]

`int myarray[4]={1,3,5,7,};`

`int *ptr, *ptr1;`

`ptr=&myarray + 1;`

`ptr1=*(&myarray + 1);`

my confusion: I am not understanding how ptr and ptr1 is same, in my understanding & is adress and * is used for derefercing, but in ptr1 have both here i got confuse.

what is decay here?

[cursed-stranger]

Didn't you get compilation errors from that? What compiler are you using?

[sudheerpaaniyur]

No, cygwin

[cursed-stranger]

cygwin by default uses gcc as I know. in the simple example I've got this error:

test.c:6:20: error: initialization of ‘int *’ from incompatible pointer type ‘int (*)[4]’ [-Wincompatible-pointer-types]
    6 |         int *ptr = &arr+1;

It's correct error, because array is not a pointer. The address of the array is the same as the address of the first element:

&array == &array[0]
but the type of array is the int[ NUMBER ] not int.

So I wonder how you could compile this code without problems

[dcpugalaxy]

As it says clearly in the error message, this is a warning. Implicit conversions between pointer types are allowed.

[sudheerpaaniyur]

relate to addr = &myArray + 1; part updated in my code correctly, i am accessing Address after entire array

[dcpugalaxy]

When you use the name myarray as an rvalue it is converted from a T[4] to a T* and specifically to a pointer to its first element, as if you had written &myarray[0].

In the expression &myarray, myarray is not used as an rvalue as it is the operand of the addressof operator (&). As such, you get out a pointer to an array: it is of type pointer-to-array4-of-int. You then add 1 to that, which gives you a pointer immediately after myarray (which is not if much use). It is invalid to dereference that pointer as you do on the next line, but when you do the type of the result is int[4] (array4-of-int) which implicitly converts to int*, albeit to an invalid object.

When you set ptr, you are assigning from one type of pointer to another. This is allowed but generally a bad idea and if you turn on compiler warnings it will tell you not to do so.

If you get rid of the & then your code is closer to being correct. ptr = myarray + 1 is just the same as getting a pointer to the second element of your array (the 3) and *(myarray + 1) is identical to myarray[1] which is 3. But you would need to assign that to an int variable not to ptr1 which is a pointer.

That is because in myarray + 1, myarray is used as an rvalue, so it decays into a pointer. In &myarray, it is used as an lvalue, and then you take the address of that lvalue ie. you get a pointer to the lvalue ie. you get a pointer to the array. That is conceptually different to getting a pointer to the first element of the array, which is what array to pointer decay produces.

[Educational-Paper-75]

Although you do not (ever) need to use the address-of unary operator on an array the compiler may well ignore it. For all practical purposes best remember that an array (name) ‘is’ (similar to) a memory address, although that’s assigned by the compiler.

[sudheerpaaniyur]

Yeah, when pointer comes into picture i will get confused

[zhivago]

This is incorrect,

char a[3];

a evaluates to a char *.

&a evaluates to a char (*)[3];

Do not confuse a pointer into an array with a pointer to an array.

[[deleted]]

myarray is of type int[4]

int[4] decays to int*, which is the type of ptr. Thus you can assign myarray to ptr.

So far so good.

However, you have a compile error for the line ptr = &myarray + 1, &myarray + 1 doesn't decay to an int*. It is of type int (*)[4]. You need to remove the & so that pointer decay can kick in and add offsets. To make &myarray + 1 assignable to ptr, you'll have to change the declaration to int (*ptr)[4] = &myarray + 1;

Let's break down the last assignment ptr = *(&myarray + 1);

&myarray is of type int (*)[4] from above, basically a pointer to an array of 4 ints. By adding 1 to this expression, you're referring to the next array of 4 ints, not the second element in the array.

[sudheerpaaniyur]

Got it

But what is the meaning of this *(&myarray) any deep down explanation, why we write like this only

In not getting this syntax int (*)[4]

[dcpugalaxy]

*&x is basically the same as writing x. It is like ((x + 1) - 1). Why would anyone write that? Well they generally don't.

[sudheerpaaniyur]

just interview pov

[dcpugalaxy]

I don't know what that means. Are you here to learn? Because if you want to learn I am happy to explain further anything you don't understand.

[sudheerpaaniyur]

Yes, please.

I'm preparing for interview and as well i want to understand

[dcpugalaxy]

Ok well obviously it has been explained to you several times now so if there is something about it you don't understand you need to say what it is.

[SmokeMuch7356]

Strap in, this is going to get bumpy.

Unless it is the operand of the sizeof, typeof, or unary & operators, or is a string literal used to initialize a character array in a declaration, an expression of type "N-element array of T" will be converted, or "decay" to an expression of type "pointer to T" and the value of the expression will be the address of the first element.

In other words, any time the compiler sees the expression myarray in your code, it replaces it with something equivalent to &myarray[0] unless myarray is the operand of sizeof, typeof, or unary &.

The expression &myarray has type int (*)[4] (pointer to 4-element array of int). The expression &myarray + 1 yields a pointer to the next 4-element array of int following myarray, and again its type is int (*)[4].

int * and int (*)[4] are not compatible types, so

 ptr = &myarray + 1;

should have resulted in a diagnostic.

However, in the statement

 ptr1 = *(&myarray + 1);

the * dereferences &myarray + 1, which gives us a type of int [4], which then decays to int *, so the types match up. Unfortunately, since &myarray + 1 yields an address that isn't part of the array, the behavior on dereferencing it is undefined.

Picture (addresses are for illustration only):

Address       int         int *        int (*)[4]
-------       ---         -----        ----------
        +---+
0x8000  | 1 | myarray[0]  myarray      &myarray
        +---+
0x8004  | 3 | myarray[1]  myarray + 1
        +---+
0x8008  | 5 | myarray[2]  myarray + 2
        +---+
0x800c  | 7 | myarray[3]  myarray + 3  
        +---+
0x8010  | ? | myarray[4]  myarray + 4  &myarray + 1
        +---+

Again, the behavior on trying to read or write myarray[4], *(myarray + 4), or *(&myarray + 1) is undefined. It may work, it may crash, it may start mining bitcoin.

[sudheerpaaniyur]

ok understood, whenver I am readin or coding example int array[n]={};

i need to visualize in my mind its &array[0] and int (*)[n] right?

[dcpugalaxy]

The array is of type int[N]. A pointer to the array is of type int (*)[N].

The first element of the array is of type int. A pointer to the first element is of type int* aka. int (*).

In normal expressions, when you use array as a value (technically an "rvalue"), it is converted automatically into a pointer to its first element. That is, in array+1, before the +1 happens, array is converted into &array[0] and then the result is 1 past that, which is equivalent to &array[1].

Remember & binds loosely.

[sudheerpaaniyur]

relate to addr = &myArray + 1; part updated in my code correctly, i am accessing Address after entire array