Pointers

Previously, we introduced reference variables. These were a way to, indirectly, have two variables pointing to the same location in memory.

Working with memory addresses is often considered quite dangerous - it can introduce some nasty bugs if not managed correctly.

Because of this, references had two restrictions, designed to ward off the most common cause of those bugs:

1. References must be initialized with a value
2. References cannot be reassigned

However, sometimes our use case requires us to do one or both of these things. For this reason, we have pointers.

The Address Of Operator: &

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

1int x { 5 };
2
3// Create a reference to x
4int& ReferenceToX { x };

1int x { 5 };
2
3// Find out where x is stored in memory
4&x;

1bool isAlive { true };

Pointers

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 variables, stored as members of a class, handed off to functions, 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}

Dereferencing Pointers

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

1// A pointer to an int
2int* PointerToInt;

1// Dereference a pointer, returning the
2// underlying value - an int, in this case
3int x { *PointerToInt };

Operator Precedence

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}

Pointers vs References

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}

The Arrow Operator: ->

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, 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();

Null Pointers

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

Summary

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.

Preview: Exploring the this Pointer

In our upcoming lesson, we'll delve into the this keyword. This special pointer points to the object on which a member function operates.

By using this, we unlock new possibilities and approaches in our code. Key Highlights of the Upcoming Lesson:

• The this Pointer: We'll explore what this is and how it inherently becomes part of every member function.
• Chainable Methods: Discover how this can enable the chaining of methods, allowing for more fluent and readable code.
• Self-Referential Code: See examples of how this can be used to compare objects or pass the current object to other functions.
• Operator Overloading: Learn how this can be used to correctly overload operators that modify their operands, such as ++ and *=.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course