Pointers

We can get the address of where a variable is stored in memory by using the & operator. This is referred to as the address-of operator.

1#include <iostream>
2using namespace std;
3
4int main(){
5  int x{1};
6
7  // Log out the location of x in memory
8  cout << &x;
9}

The above program will output a memory address, which may look something like the following:

10x7ffe88a53e88

1bool isAlive { true };

What gets returned from the & operator is referred to as a pointer. It points to a location in memory. A pointer is a value like any other - it can be stored in a variable, stored as member of a class, handed off to a function, and more.

A pointer type includes the underlying type (ie, the type of data being pointed at), and a * suffix.

For example:

• A pointer to an int is an int*
• A pointer to a bool is a bool*
• A pointer to a Character (a user-defined type) is a Character*

For example, if we wanted a variable called MyPointer to store a pointer to an int, we could declare it like this:

1int* MyPointer;

If we use the address-of operator, & on a variable containing an int, we will get an int* - a pointer to an int

We can store that like any other variable:

1int x { 1 };
2int* MyPointer { &x };

And we can pass them to functions:

1void HandlePointer(int* Pointer) {
2  // ...
3}
4
5int main() {
6  int x{42};
7  HandlePointer(&x);
8}

With references, we could just work with the reference as if it were the base data type. We could use a reference to an int (an int&) as if it were an int.

We can't do that with pointers. To access the value that a pointer points to, we first need to visit the memory address the pointer is pointing at, and get the value stored there. This is referred to as dereferencing the pointer and it is done using the * operator.

The * operator returns an object of the underlying type. For example, dereferencing an int* (a pointer to an int) will return an int (a simple int value)

1#include <iostream>
2using namespace std;
3
4void HandlePointer(int* Pointer){
5  int Dereferenced{*Pointer};
6  cout << "Dereferenced: " << Dereferenced;
7}
8
9int main(){
10  int x{42};
11  HandlePointer(&x);
12}

1Dereferenced: 42

Previously, we covered how operators have different precedence. When we have multiple operators acting in a single expression, precedence controls what happens first.

For example, in an expression like 1 + 2 * 3, multiplication happens first.

Precedence rules apply to non-arithmetic operators too, such as the dereferencing operator.

For example, the following code will not compile:

1int main() {
2  int x{42};
3  int* Pointer(&x);
4  *Pointer++;
5}

This is because the incrementing ++ operator has higher precedence than the dereferencing operator *, so it happens first. It's equivalent to this:

1int main() {
2  int x{42};
3  int* Pointer(&x);
4  *(Pointer++);  
5}

The dereferencing operator has fairly low precedence in general, so when using it, we will often need to introduce brackets to ensure it happens first:

1int main() {
2  int x{42};
3  int* Pointer(&x);
4  (*Pointer)++;  
5}

To put all these concepts together, let's look at how we can get our Increment() function that we originally implemented with references to use pointers instead. Here's the version using a reference:

1void Increment(int& Number){
2  Number++;
3}
4
5int main(){
6  int x{1};
7  Increment(x);
8}

And here it is using a pointer:

1void Increment(int* Number){
2  (*Number)++;
3}
4
5int main(){
6  int x{1};
7  Increment(&x);
8}

The notable changes here are:

On line 1: Our function no longer accepts an int& (a reference to an integer). Instead, it now expects an int* (a pointer to an integer)

On line 2: Our function body can no longer treat Number as an integer. It is now a pointer, so we need to dereference it before accessing or modifying the underlying value

On line 7: We can no longer just pass an int into our function and have the compiler implicitly convert it to the correct type for us automatically.

When using a pointer, we need to be more explicit. Therefore, we use the address-of operator & to ensure our function receives the pointer it expects.

1void Double(int* Number) {
2  // ??
3}

When we're working with pointers to our custom types, a common requirement we'll have is to dereference the pointer, and then access one of its members.

The member access operator . has higher precedence than the dereferencing operator *, so we need to use brackets here:

1void Combat(Monster* Enemy){
2  (*Enemy).TakeDamage(50);
3}

C++ provides an alternative syntax for this, typically called the arrow operator. We can think of it as combining the dereferencing operator * and the member access operator .:

1void Combat(Monster* Enemy){
2  Enemy->TakeDamage(50);
3}

This is much more common, therefore, it will be our preferred approach going forward.

Note, that we only use the -> operator with pointers to an object. When we have the actual object by value, or a reference to it, the . is still used to access its members.

1// We use . with objects
2Character MyCharacter;
3MyCharacter.TakeDamage(50);
4
5// We use . with references
6Character& Reference { MyCharacter };
7Reference.TakeDamage(50);
8
9// We use -> with pointers
10Character* Pointer { &MyCharacter };
11Pointer->TakeDamage(50);

1class Weapon {
2public:
3  void Equip() {}
4};
5
6void PrepareForBattle(Weapon SelectedWeapon) {
7  // ???
8}

1SelectedWeapon.Equip();

1SelectedWeapon->Equip();

1*SelectedWeapon.Equip();

1class Weapon {
2public:
3  void Equip() {}
4};
5
6void PrepareForBattle(Weapon& SelectedWeapon) {
7  // ??
8}

1SelectedWeapon.Equip();

1SelectedWeapon->Equip();

1*SelectedWeapon.Equip();

1class Weapon {
2public:
3  void Equip() {}
4};
5
6void PrepareForBattle(Weapon* SelectedWeapon) {
7  // ??
8}

1SelectedWeapon.Equip();

1SelectedWeapon->Equip();

1*SelectedWeapon.Equip();

When working with pointers, we'll often need a way to represent empty values.

For example, we may be making a game where our player can have a weapon:

1class Weapon {};
2
3class Character {
4public:
5  Weapon* mWeapon;
6};

To make a pointer point to nothing, representing the absence of a value, we use the nullptr keyword:

1class Weapon {};
2
3class Character {
4public:
5  Weapon* mWeapon{nullptr};
6};

We should never attempt to dereference a nullptr using the * or -> operator. If we need to dereference a pointer, and we think it may be a nullptr, we can first check for that condition using an if statement:

1#include <iostream>
2using namespace std;
3
4class Weapon {
5public:
6  string mName{"Iron Sword"};
7};
8
9class Character {
10public:
11  Weapon* mWeapon{nullptr};
12};
13
14int main(){
15  Character Player;
16  Weapon Sword;
17  if (!Player.mWeapon) {
18    cout << "I am unarmed";
19  }
20  Player.mWeapon = &Sword;
21  if (Player.mWeapon) {
22    cout << "\nBut not any more! Behold my "
23      << Player.mWeapon->mName;
24  }
25}

1I am unarmed
2But not any more! Behold my Iron Sword

Finally, let's see a slightly more complex example. Our classes can contain references to other objects of the same class.

For example, a Character can have a member variable that is a reference or a pointer to another Character object.

This is the case for the mEnemy variable within our Character class below:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  Character(string Name): mName{Name}{}
7
8  void SetEnemy(Character* Enemy){
9    mEnemy = Enemy;
10  }
11
12  void LogEnemy(){
13    if (mEnemy) {
14      cout << "\nEnemy: " << mEnemy->mName;
15    } else {
16      cout << "\nI don't have an enemy";
17    }
18  }
19
20  string mName;
21  Character* mEnemy{nullptr};
22};
23
24int main(){
25  Character Player{"Anna"};
26  Player.LogEnemy();
27
28  Character Enemy{"Goblin Warrior"};
29  Player.SetEnemy(&Enemy);
30  Player.LogEnemy();
31
32  Character AnotherEnemy{"Vampire Bat"};
33  Player.SetEnemy(&AnotherEnemy);
34  Player.LogEnemy();
35}

1I don't have an enemy
2Enemy: Goblin Warrior
3Enemy: Vampire Bat

Uninitialized Variables

A somewhat counterintuitive behaviour of C++ is that pointers are not created in the nullptr state by default. Assuming an uninitialized pointer is a nullptr is a common source of bugs.

In the following program, we might expect Ptr to be empty, but that is not the case:

1#include <iostream>
2using namespace std;
3
4int main() {
5  int* Ptr;
6  if (Ptr) {
7    cout << "Ptr is NOT a nullptr";   
8  }
9}

1Ptr is NOT a nullptr

Compilers can typically detect this problem in the simple case, and will issue a warning:

1main.cpp:6:7: warning: variable 'Ptr' is uninitialized when used here

If we want a pointer to initially be empty, we need to explicitly initialize it as a nullptr:

1#include <iostream>
2using namespace std;
3
4int main() {
5  int* Ptr{nullptr};
6  if (!Ptr) {
7    cout << "Now it is";   
8  }
9}

1Now it is

Why does C++ Work This Way?

C++ has a "zero overhead" design philosophy. This means that it will not perform unnecessary work unless asked to do so, as unnecessary work has a performance cost.

Visiting a memory address and updating it to store some initial value falls into this category, so it isn't done unless we explicitly ask for it.

If we create a variable without an initial value, the memory address associated with that variable continues to use whatever the previous value happened to be. Using an uninitialized variable results in unpredictable and undefined behavior:

1#include <iostream>
2using namespace std;
3
4int main() {
5  int x;
6
7  if (x) {
8    cout << "x is: " << x;
9  }
10}

1x is 85

There is no reason we would want to do this, so most compilers can detect and issue warnings in simple cases:

1main.cpp:8:25: warning: variable 'x' is uninitialized when used here [-Wuninitialized]

Whilst this undefined behavior is true of fundamental, built-in types like int and pointers, it's not necessarily true of all types. As we've seen, more complex types can have a default constructor defined as part of their class or struct.

For those types, that default constructor controls what happens when objects are created without initial values.

In this lesson, we explored the fundamental concepts of pointers. The key points include:

• Understanding the address-of operator (&) and how it differs from a reference.
• Learning about pointers, their declaration, and how they point to memory locations.
• Grasping the concept of dereferencing pointers to access or modify the value at the memory address they point to.
• Recognizing the importance of operator precedence in expressions involving pointers.
• Comparing pointers and references, understanding their uses, and the advantages of references in certain scenarios.
• Utilizing the arrow operator (>) for member access in objects pointed to by pointers.
• Handling null pointers using nullptr and ensuring safety checks before dereferencing.