References and Pointers

This lesson is a quick introductory tour of references and pointers within C++. It is not intended for those who are entirely new to programming. Rather, the people who may find it useful include:

• those who have completed our introductory course, but want a quick review
• those who are already familiar with programming in another language, but new to C++
• those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course. Anyone looking for more thorough explanations or additional context should consider Chapter 5 of that course.

Previous Course

Intro to Programming with C++

Starting from the fundamentals, become a C++ software engineer, step by step.

View Course

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.

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

11
2

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

References

We can store and pass values 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 << MyNumber;
11}
12

12
2

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, which has a performance impact when dealing with more complex objects.

We’re not restricted to just creating references as part of a function call. We can freely create them as needed.

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

12
2

Constants using const

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}
5

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}
4

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};
11

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”.

Pointers

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;
2

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 something, we need to get it’s address 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 << MyNumber;
5}
6

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. This code will log out 1:

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

The * operator has fairly low precedence, so we often need to introduce brackets when we’re combining * with other operators. The following code will log out 2:

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

When a pointer is pointing to an object, we have the arrow operator, -> which combines both the dereferencing operator (*) and the member access operator (.).

The following code shows two ways of accessing a member variable through a pointer:

1Vector MyVector{1.f, 2.f, 3.f};
2Vector* Pointer{&MyVector};
3
4std::cout << (*Pointer).x;
5std::cout << Pointer->x;
6

Null Pointers

An uninitialized pointer points to a random memory location. This will log out a random memory address:

1int* Pointer;
2std::cout << Pointer << endl;
3

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

1int* Pointer{nullptr};
2

Dereferencing a null pointer will result in undefined behavior, but we can check if a pointer is null at run time. The following code will compile and run successfully, but will not log out anything because nullptr is falsey:

1int* Pointer{nullptr};
2
3if (Pointer) {
4  std::cout << *Pointer;
5}
6

const Pointers

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 implementations. 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;
7

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;
8

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;
8

Pointers to Pointers

Like any data type, pointers themselves are also stored in memory. As such, we can have pointers to pointers:

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

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

This is somewhat niche and, if we find ourselves doing this, there’s probably a way we can restructure our code to eliminate this complexity.

Memory Ownership and Smart Pointers

The concept of memory ownership may be familiar to those coming to C++ from other languages. The pointers we covered here are sometimes referred to as raw pointers. They do not implement any form of ownership, and memory management is left to us as developers.

The C++ standard library includes smart pointers, which implement a memory ownership model and automated management. We cover smart pointers, and memory management in general, later in this course.