# Bold Aesthetic Creative Games

An Indie Game Studio Developing Bold, Aesthetic & Creative Video Games

# C++ Programming Series: Pointers (Part 4, Last)

## C++ Programming Series: Pointers (Part 4, Last)

Too busy! Too busy! Don’t expect regular and weekly posts from me.

In the previous post, we discussed that pointers are actually arrays! This post is to discuss more pointers, arrays and the arithmetic that can be done with them.

We can do addition and subtraction with pointers. Multiplication and division are not possible! Here is the code giving an example of pointer arithmetic (try to understand it deeply):

``````int array[] = {20, 30, 40, 50, 60};
int* pArray = array;

pArray++;
cout << *pArray << endl; //Prints 30, same as array[1]

pArray++;
cout << *pArray << endl; //Prints 40, same as array[2]
cout << pArray[2] << endl; //Prints 60, same as array[4]
//pArray[4] will give error or garbage value!

pArray -= 2;
cout << *pArray << endl; //Prints 20, same as array[0]
cout << pArray[4] << endl; //Prints 60. same as array[4]``````

When we increment a pointer of type `int`, the address is actually shifted by the number of bytes that an integer consists of. Similarly, when we increment a pointer of type `string`, the address is shifted 4 bytes forward. The opposite happens when we decrement a pointer.

Consider the code below:

``````string words[] = { "First", "Second", "Third", "Fourth", "Fifth" };
string* pWords = words;``````

Now, `pWords` is pointing towards the memory address of `words[0]` or “First”. If we add one into it:

``pWords++; //or pWords += 1;``

…then it will be shifted 4 bytes forwards to reach the next string of the array, `words`. Or in other words, `pWords` is now, equivalent to `&words[1]`. Now, if we subtract one from it, it will get to the same address as before.

C++ is a very flexible language. We can add the numbers into the pointer temporarily like `pWords + 3`. Now, if `pWords` is equivalent to `&words[0]`, then `pWords + 3` would give us the address equal to `&words[3]`. If we dereference this memory address, we will get the proper string value, “Fourth” like this:

``````string words[] = { "First", "Second", "Third", "Fourth", "Fifth" };
string* pWords = words;

//fourth element of the array and dereferencing that memory
//address to get the value from there
cout << *(pWords + 3) << endl; //Prints "Fourth"``````

Isn’t that similar to that?

``cout << pWords[3] << endl; //Prints "Fourth"``

Yes, they are completely the same! What is happening with `pWords[3]` is the same as what is happening with `*(pWords + 3)`.

That’s it! Your exercise is to find out what is the output of the code below (without checking it out in the compiler):

``````int array[] = { 1,2,3,4,5,6,7,8,9,10 };
int* pArray = array;

pArray += 5;
cout << pArray[3] << endl; //Output 1

pArray -= 3;
cout << pArray[4] << endl; //Output 2

pArray--;
cout << *pArray << endl; //Output 3

pArray + 2;
cout << *pArray << endl; //Output 4

pArray += 1;
cout << *(pArray + 1) << endl; //Output 5``````

That is all pointers for you. Congratulations! You learned the pointers! Time to step ahead…