Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

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!

like image 506
Austin Moore Avatar asked Nov 21 '11 04:11

Austin Moore


People also ask

What is an array of pointers explain with example?

In computer programming, an array of pointers is an indexed set of variables, where the variables are pointers (referencing a location in memory). Pointers are an important tool in computer science for creating, using, and destroying all types of data structures.

How do you define an array pointer?

In this program, we have a pointer ptr that points to the 0th element of the array. Similarly, we can also declare a pointer that can point to whole array instead of only one element of the array. This pointer is useful when talking about multidimensional arrays.

Can a pointer access the array?

we can access the array elements using pointers.

Why do we use pointers in arrays?

Pointers are used for storing address of dynamically allocated arrays and for arrays which are passed as arguments to functions.


2 Answers

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
like image 195
Pubby Avatar answered Oct 15 '22 09:10

Pubby


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"
like image 39
Mark Ransom Avatar answered Oct 15 '22 09:10

Mark Ransom