C++ understanding pointers - c++

Question

I have a bit of code that I'm trying to analyze to study up on pointers and I'd like to ask for some help on whether I'm interpreting it correctly and if I'm not can someone help interpret it for me because I still find pointers to be confusing. You will be able to see my interpretations right after the //.
int main()
{
int x = 5;
int y = 3;
int a[] = {5, 10, 15};
PointerMystery(&x, y, a);
cout << x << " " << y << endl;
for (int i = 0; i < 3; i++) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
void PointerMystery(int *pa, int b, int c[]) {
// *pc will return array c
int *pc = c;
// *pa which returns the address of x will now make x = 20.
*pa = 20;
// b which was 3 is now equal to 15, therefore y = 15
b = 15;
// *pc which returned a array is now 15(im not so sure about this?)
*pc = b;
// im not sure what is happening here either?
pc += 2;
// *pc will return the value (20) - 10?
*pc = *pa - 10;
cout << *pa << " " << b << " " << *pc << endl;
for (int i = 0; i < 3; i++) {
cout << c[i] << " ";
}
cout << endl;
}

Answer 1

Pointer variables are just what their names implies, variables that point to something.
It might be easier to understand if you think about it graphically, and step by step. So...
When the PointerMystery function is called you have the variables pa, b and c:
+----+ +---+
| pa | --> | 5 |
+----+ +---+
+---+
| 3 |
+---+
+---+ +----+----+----+
| c | --> | 5 | 10 | 15 |
+---+ +----+----+----+
After you assign pc you have
+---+
| c | --\
+---+ \ +----+----+----+
>-> | 5 | 10 | 15 |
+----+ / +----+----+----+
| pc | -/
+----+
You then do *pa = 20; so you have
+----+ +----+
| pa | --> | 20 |
+----+ +----+
Then you do *pc = b;, where b is 15, and since pc really just points to the first element of the passed array that mean you change the first element:
+---+
| c | --\
+---+ \ +----+----+----+
>-> | 15 | 10 | 15 |
+----+ / +----+----+----+
| pc | -/
+----+
You then increase the pointer pc to point to the third element of the passed array:
+---+ +----+----+----+
| c | --> | 15 | 10 | 15 |
+---+ +----+----+----+
^
+----+ |
| pc | -------------/
+----+
You then change the value where pc is pointing to the value of where pa is pointing minus 10, and the value of where pa is pointing is 20 which gives 10 after the subtraction:
+---+ +----+----+----+
| c | --> | 15 | 10 | 10 |
+---+ +----+----+----+
^
+----+ |
| pc | -------------/
+----+
Other things that might be good to know about pointers, is that arrays decays to pointers to their first element when you pass them to a function. That's the reason that c is a pointer and where it points.
Also, you can use both array indexing syntax and pointer syntax for both arrays and pointer. You can do this for arrays since they decays to pointers to their first element, and for pointers as a short-hand for *(ptr + x). In fact, for both pointers and arrays, *(ptr_or_array + x) is equivalent to ptr_or_array[x].
The last bit also explains why adding two to the pc pointer makes it points to the third element, *(pc + 0) is equivalent to pc[0] and *(pc + 2) is equivalent to pc[2], which since array indexes are zero based is the third element.