Array subscript notation and derefencing

Question

Hi all I have a question about the following code and want to verify some of my assertions.

int array[] = {1,2,3,4};
int* ptr = &array[1];

Does &array[1] mean I get the address of the array and add 1 to it, deference that address to see the actual integer and then take the address of the integer which is stored in that address?

How is this done? Is there a operator[](int index) for array that returns a reference and then we takes its address?

I want to understand what the machine is actually doing and the language semantics for this.

It could be done like that, but it would make no sense to do so. For a practical, actual implementation, the generated code is the same as that of normal pointer arithmetic using the `+` operator (`array + 1`). — , Jun 12 '13 at 13:38
Array-pointer-decay is what you're trying to understand: http://stackoverflow.com/q/4810664/183120 — legends2k, Jun 12 '13 at 13:42

score 6 · Answer 1 · answered Jun 12 '13 at 13:38

6

int* ptr = &array[1];

is equivalent to :

int* ptr = & ( *(array + 1) );

*(array+1) matches the second cell of your array. Then you're affecting the address of this cell to your pointer. What you're doing is equivalent to :

int* ptr = array+1

answered Jun 12 '13 at 13:38

ibi0tux

2,481
4
28
49

Mike Seymour · Accepted Answer · 2013-06-12T14:06:37.827

Does this mean get the address of the array and add 1 to it, dereference that address to see the actual integer and then take the address of the integer which is stored in that address?

Yes. Equivalently, it just means "add one to the address of the array", since dereferencing then taking the address gives you the address you started with.

How is this done? Is there a operator[](int index) for array that returns a reference and then we takes its address?

Almost. The built-in subscript operator, when used to apply an index to a pointer as p[i], is defined to give an lvalue referring to *(p+i). When applied to an array, the array is first converted to a pointer to its first element. That is one of the standard implicit conversions: the array-to-pointer conversion, sometimes referred to as "decaying". Taking the address of the lvalue gives a pointer to the array element.

Fantastic just the sort of detail I was actually after. Thank you. — Blair Davidson, Jun 12 '13 at 13:59

score 0 · Answer 3 · answered Jun 12 '13 at 13:37

0

Yes. You will find that you can set int* arrPtr=array;, meaning that array can be treated as a pointer. array[1]; means "take the pointer to the start of array array, shift it over one, and dereference. &array[1]; means "get the pointer to that dereferenced value." array[1]; is equivalent to *(array+1);.

answered Jun 12 '13 at 13:37

IanPudney

5,941
1
24
39

The last statement is wrong. `&array[1]` is equivalent to `array + 1`. – Jun 12 '13 at 13:39
Oops, I just changed that because I misread what I had already written! I've put it back. – IanPudney Jun 12 '13 at 13:42

score 0 · Answer 4 · answered Jun 12 '13 at 13:38

Probably because of different possible types, the array index is first executed (read: array[1] is first 'get') and then & goes into action and get's the address. While if you had a long long, get the address of array[0] and add 1 to it you would be reading the first 8bytes from another alignment (you are reading the last 3 bytes of the 1st index , then 7 bytes from the second )

Array subscript notation and derefencing

4 Answers4