Understanding Reference and Pointer Types

By default, variables in C++ are passed by value. That is, when we pass objects into functions, the function receives a copy of that object.

We see an example of this below:

1#include <iostream>
2
3void Increment(int Number){
4  ++Number;
5}
6
7int main(){
8  int MyNumber{1};
9  Increment(MyNumber);
10  std::cout << "Value: "
11    << MyNumber;
12}

1Value: 1

This function logs 1 as the Increment function received a copy of MyNumber. The original value within the main function was unchanged by the function call.

We can pass by reference instead. A reference, and the variable it was created from, both point to the same memory location. A reference type has the & character appended to the underlying type. For example, a reference to an int has the type int&:

1#include <iostream>
2
3void Increment(int& Number){
4  ++Number;
5}
6
7int main(){
8  int MyNumber{1};
9  Increment(MyNumber);
10  std::cout << "Value: "
11    << MyNumber;
12}

1Value: 2

When dealing with more complex types, having our functions receive references rather than values is generally preferred where possible. This is because passing by value requires the original variable to be copied. This isn't a problem with simple types like int and float, but with larger types, unnecessary copying has a performance cost.

We're not restricted to just creating references as part of a function call. We can freely create them as needed. Below, we create a reference to MyNumber, and we then increment MyNumber through that reference:

1#include <iostream>
2
3int main(){
4  int MyNumber{1};
5  int& Ref{MyNumber};
6  ++Ref;
7  std::cout << "Value: "
8    << MyNumber;
9}

1Value: 2

Variables and parameters can be marked as constants in C++ using the const keyword. This will cause the compiler to throw an error if an attempt is made to modify such a variable:

1int main(){
2  const int MyInteger{1};
3  MyInteger++; 
4}

This is most useful when working with references. When we create a function that receives a reference, the developers who call that function are often going to want to know if their variable is going to be modified.

If our function does not modify a parameter, we should mark it as const in our parameter list:

1void LogNumber(const int& Number){
2  std::cout << Number;
3}

If we try to modify a variable we marked as const, the compiler will alert us to the error.

This is also the case if we do something that may indirectly cause the variable to be modified. This can include passing it off by reference to another function that hasn't marked the parameter as const, or calling a method on the object that isn't marked as const

To mark methods or operators as const, we include that keyword in our function signatures:

1struct Vector {
2  float x;
3  float y;
4  float z;
5
6  // A const method cannot modify the object
7  float GetLength() const{
8    ++x; 
9  }
10};

Marking things as const is not required, but is highly desirable if the variable is not intended to be modified. Code that does this correctly is said to be const correct.

References implement two restrictions:

• References must be initialized with a value
• References cannot be updated to point to something else

These two restrictions simplify our lives, by preventing most of the common pitfalls that occur when dealing with memory addresses. However, sometimes our requirements are more complex, and we need to remove those restrictions. For this, we have pointers.

Pointers have the * character appended to their data type. For example, a pointer to an int has the type of int*:

1int* PointerToAnInteger;

Whilst references and the values they point at can be implicitly converted to each other and used in the same way, that's not the case for pointers. To make a pointer point at an object, we need to get where that object is stored in memory.

We can do that using the unary address-of operator, &:

1int main(){
2  int MyNumber{1};
3  int* Pointer{&MyNumber};
4  std::cout << Pointer;
5}

This code will log out a member address, which will look something like 0x7ffe88a53e88

To access the value of a memory address stored in a pointer, we need to dereference it, using the unary * operator:

1int main(){
2  int MyNumber{1};
3  int* Pointer{&MyNumber};
4  std::cout << "Value: " << *Pointer; 
5}

1Value: 1

The * operator has fairly low precedence, so we often need to introduce brackets when we're combining * with other operators:

1int main(){
2  int MyNumber{1};
3  int* Pointer{&MyNumber};
4
5  std::cout << "Value: " << (*Pointer) + 1;
6}

1Value: 2

As an alternative to the dereferencing operator * we can often use the arrow operator, ->, instead. We can think of this as being like a combination of the dereferencing operator (*) and the member access operator (.).

The following code shows two ways of accessing a member variable through a pointer. The second option, using the arrow operator, saves a few keystrokes and makes our expressions more readable:

1struct SomeType {
2  float x;
3  float y;
4}
5
6int main() {
7  SomeType  SomeObject{1.f, 2.f};
8  SomeType* Pointer{&SomeObject};
9
10  // Option 1:
11  (*Pointer).x;
12
13  // Option 2:
14  Pointer->x;
15}

An uninitialized pointer points to a random memory location.

1int* Pointer;

This is quite dangerous as if we dereference it, we don't know what we're accessing. Additionally, in a complex program, we cannot easily determine if a pointer is uninitialized.

If we intentionally want a pointer to point to nothing, we should set its value to nullptr:

1// Initialize a pointer to point at nothing
2int* Pointer{nullptr};
3
4// Update an existing pointer to point at nothing
5Pointer = nullptr;

Dereferencing a null pointer will result in undefined behavior, but unlike uninitialized pointers, we can check if a pointer is null.

A nullptr is falsey, so if we want to check if a pointer is pointing at something before dereferencing it, we can use a simple conditional statement:

1int* Pointer{nullptr};
2
3if (Pointer) {
4  std::cout << *Pointer;
5} else {
6  std::cout << "That was a nullptr";
7}

1That was a nullptr

Given that references cannot be updated to point at something else, the use of const in that context was perhaps clear - a const reference means the value cannot be modified.

However, with pointers, there's some additional complexity, because pointers can be updated to point to something else.

So, the use of const in a pointer data type can have three different interpretations. Here, we demo them using an integer, but it applies to any underlying data type:

1. Pointer to a const

The value being pointed at is const, meaning it can't be modified. But, the pointer can be updated to point at something else:

1int x{1};
2int y{2};
3const int* Pointer{&x};
4
5(*Pointer)++;
6Pointer = &y;

2. const Pointer

The pointer can be const, meaning it cannot be updated to point to something else. But, the value it is pointing at can still be modified:

1int x{1};
2int y{2};
3
4int* const Pointer{&x};
5
6(*Pointer)++;
7Pointer = &y;

3. const Pointer to a const

Finally, both the pointer and the value it is pointing to can be marked as const, meaning neither can be modified:

1int x{1};
2int y{2};
3
4const int* const Pointer{&x};
5
6(*Pointer)++;
7Pointer = &y;

Like any data type, pointers themselves are also stored in memory. As such, we can have pointers to pointers. In the following example, PtrB points to PtrA, which points to Number:

1int   Number{5};
2int*  PtrA{&Number};
3int** PtrB{&PtrA};
4
5std::cout
6  << "PtrB -> " <<   PtrB << "\n"
7  << "     -> " <<  *PtrB << "\n"
8  << "     -> " << **PtrB;

1PtrB -> 0x7ffcacb0e8e0
2      -> 0x7ffcacb0e8ec
3      -> 5

This is rarely necessary. If we find ourselves doing this, there's probably a way we can restructure our code to eliminate this complexity.

In this lesson, we explored references and pointers in C++, learning how to work with variables in new ways. Key takeaways:

• References provide an alternative name for an existing variable, while pointers store memory addresses
• The const keyword can be used with references and pointers to prevent modification
• The arrow operator -> is a convenient way to access members through a pointer
• Null pointers should be used when a pointer intentionally points to nothing
• Be cautious when working with memory addresses, as they can add bugs and complexity to your code