CODEWITHSUNDEEP
c++arrayspointers
Austin Moore
Austin Moore

Reputation: 1412

Can someone clarify this array/pointer idea to me?

In attempt to explain that arrays are just pointers (in C++) to our class, my professor showed us this:

array[5]      // cout'ing this 
*(array + 5)  // would return the same value as this

I'm having a little trouble completely understanding it. Here's my thinking:

array is the address of the first location and so if we add 5 to that address, we move 5 addresses in memory. The pointer operator pulls the data from the memory location.

Is this the correct idea? The idea still feels foggy with me and just feel like I don't understand it completely. I think hearing someone else explain it might help me understand it more. Thanks in advance!

Upvotes: 5

Views: 171

Answers (4)

M S
M S

Reputation: 4093

Yes, what your proffessor said is correct.

to explain it in detail

Consider your array, 

int array[5]

here it takes 5 location in the memory say 0x00 0x04 0x08 0x0C and 0x10 0x14

Assuming integer takes 4 bytes, the locations are 4 bytes apart.

it this case 'array' represents the base address (pointer) to the array, that is 0x00. And the type of a would be int *. (since the type of the array elements is integer)

If you do array+1, it will be 0x04, since the increment of the pointer depends on the type of the pointer. If the pointer is integer, it will increment by 4 bytes. If the type of the integer is character, the pointer would increment by one bytes.

so if you do (array+5) it would point to the address 0x14 and

*(array+5)

returns the value of the location 0x14 which is the value at 5th location of array.

so in practical, array[5] is equal to *(array+5)

The compiler internally converts array[5] to *(array+5)

so even if we write 5[array], it will get converted it to *(5+array)

Though it seems strange, this is the reason why 5[array] works same as array[5]

Upvotes: 2

Pubby
Pubby

Reputation: 53027

You've got the right idea.

Arrays implicitly cast to pointers. Interestingly, [] works on pointers, not arrays.

a[b] Subscript operator is defined as *(a + (b)). [] is used as syntactic sugar - it's much more pleasant to write array[5] instead of *(array + 5)

Pointer arithmetic with a pointer and an integer p + i increases the address at p by i * sizeof(*p) bytes. 

char* p; 
p + 5; // address increased by 5

int* p;
p + 5; // address increased by 20 as sizeof(*p) is 4

The * operator performs indirection. It will give you what the pointer is pointing to. 

int x[2];
int* p = &x[0]; // could also be int* p = x;
*p = 5;         // x[0] is now 5
*(p + 1) = 10;  // x[1] is now 10

Upvotes: 4

Mark Ransom
Mark Ransom

Reputation: 308121

Your professor is correct that the two expressions will produce the same results. Your explanation of it leads me to believe you have a good grasp of the mechanics.

It is not quite correct to say an array is the same as a pointer. An array is very easily converted to a pointer, which leads to some confusion.

For example consider this code:

int array[5];
int * pointer = new int[5];
cout << sizeof(array);   // outputs 5*sizeof(int), most probably 20
cout << sizeof(pointer); // outputs sizeof(int*), most probably 4 on a 32 bit OS
array[4] = 906;
pointer[4] = 906;
cout << *(array + 4) << *(pointer + 4); // outputs "906 906"

Upvotes: 4

CStreel
CStreel

Reputation: 2642

from memory arrays in c++ are sections of continuous memory the program. thats why you can go *(array + 5) as it is 5 from the front of the array.

Also keep in mind that arrays in C++ start @ 0 so thus the 6th element in an array is array[5] example

[0] [1] [2] [3] [4] [5] Array index
 1   2   3   4   5   6  Item number

To access item 2 u would either

  • array[1]
  • *(array+1)

but please keep in mind array[index_number] is standard syntax for looking up an item in an array so make sure u use array[index_num] instead of *(array + index_num)

Upvotes: 2

Related Questions