Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


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 are 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 completing _**Chapter 5**_ of that course.


</Excerpt>


<CoursePromo course="intro" />


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:


```c++
#include <iostream>

void Increment(int Number){
  ++Number;
}

int main(){
  int MyNumber{1};
  Increment(MyNumber);
  std::cout << "Value: "
    << MyNumber;
}
```


```c++
//<o>
Value: 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.


<Ad />


## References


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&`:


```c++
#include <iostream>

void Increment(int& Number){//<h>
  ++Number;
}

int main(){
  int MyNumber{1};
  Increment(MyNumber);
  std::cout << "Value: "
    << MyNumber;
}
```


```c++
//<o>
Value: 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.  Below, we create a reference to `MyNumber`, and we then increment `MyNumber` through that reference:


```c++
#include <iostream>

int main(){
  int MyNumber{1};
  int& Ref{MyNumber};
  ++Ref;
  std::cout << "Value: "
    << MyNumber;
}

```


```c++
//<o>
Value: 2
```


<Ad />


## 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:


```c++
int main(){
  const int MyInteger{1};
  MyInteger++; //<e>
}
```


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:


```c++
void LogNumber(const int& Number){//<h>
  std::cout << Number;
}
```


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:


```c++
struct Vector {
  float x;
  float y;
  float z;

  // A const method cannot modify the object
  float GetLength() const{
    ++x; //<e>
  }
};
```


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**_.


<Ad />


## 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*`:


```c++
int* 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, `&`:


```c++
int main(){
  int MyNumber{1};
  int* Pointer{&MyNumber};//<h>
  std::cout << MyNumber;
}
```


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:


```c++
int main(){
  int MyNumber{1};
  int* Pointer{&MyNumber};
  std::cout << "Value: " << *Pointer; //<h>
}
```


```c++
//<o>
Value: 1
```


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


```c++
int main(){
  int MyNumber{1};
  int* Pointer{&MyNumber};

  std::cout << "Value: " << (*Pointer) + 1;//<h>
}
```


```c++
//<o>
Value: 2
```


<Aside>


### The Confusing `&` and `*` Syntax


A large source of confusion when it comes to references and pointers is the overuse of the `&` and `*` syntax.


The `&` syntax is used in both cases and, even though the `&` symbol is the same, it has a different meaning depending on where it is used in our code:


**When** **`&`** **appears after a type:** it is part of the _**type**_. For example, `int&` is a type - specifically a reference to an `int`.


**When** **`&`** **appears before a variable:** it’s an _**operator**_ that will get the memory address of that variable. For example, `&MyVariable` returns the memory address of `MyVariable`. Memory addresses are pointers, so what it returns is a pointer.


Similarly, the `*` syntax has multiple meanings depending on how it is used:


**When** **`*`** **appears after a type:** it is part of the _**type**_. For example, `int*` is a type - specifically a pointer to an `int`.


**When** **`*`** **appears before a variable:** it's an _**operator**_. Typically, it’s an operator that is used with pointer types, where it’s an instruction to visit the memory location that the pointer is pointing at and return the value that is stored there.


For example, let’s imagine `MyVariable` is an `int*` - a pointer to an `int`. Then, `*MyVariable` will visit the memory address, and return the `int` stored there.


</Aside>


## The Arrow Operator `->`


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:


```c++
Vector MyVector{1.f, 2.f, 3.f};
Vector* Pointer{&MyVector};

// Option 1:
(*Pointer).x;//<h>

// Option 2:
Pointer->x;//<h>
```


<Ad />


## Null Pointers


An uninitialized pointer points to a random memory location.


```c++
int* Pointer;//<w>
```


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`:


```c++
int* Pointer{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:


```c++
int* Pointer{nullptr};

if (Pointer) {//<h>
  std::cout << *Pointer;
} else {
  std::cout << "That was a nullptr";
}
```


```c++
//<o>
That was a nullptr
```


<Ad />


## `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 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:


```c++
int x{1};
int y{2};
const int* Pointer{&x};

(*Pointer)++;//<e>
Pointer = &y;//<h>
```


### 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:


```c++
int x{1};
int y{2};

int* const Pointer{&x};

(*Pointer)++;//<h>
Pointer = &y;//<e>
```


### 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:


```c++
int x{1};
int y{2};

const int* const Pointer{&x};

(*Pointer)++;//<e>
Pointer = &y;//<e>
```


<Ad />


## Pointers to Pointers


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


```c++
int Number{5};
int* PtrA{&Number};
int** PtrB{&PtrA};

std::cout << "   " << PtrB << "\n"
          << "-> " << *PtrB << "\n"
          << "-> " << **PtrB;
```


```c++
//<o>
   0x7ffcacb0e8e0
-> 0x7ffcacb0e8ec
-> 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.


<Aside>


### 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 when working with them, 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.


</Aside>


## Summary


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

<FAQ>


```javascript
//<m>
{
  slug: 'passing-references-to-const',
  title: 'Passing References to const',
  question: 'Why should I pass references to `const` when a function does not modify its arguments?',
}
```


Passing references to `const` is a best practice in C++ for several reasons:

1. It clearly communicates to other developers that the function will not modify the argument.
2. It allows the function to accept both non-const and const arguments. If you don't use `const`, you can only pass non-const arguments.
3. It can avoid unnecessary copying of large objects, which can improve performance.

Here's an example:


```c++
#include <iostream>

struct Vector {
  float x;
  float y;
  float z;
};

void PrintVector(const Vector& v) {
  std::cout << "Vector: (" << v.x << ", "
    << v.y << ", " << v.z << ")\n";
}

int main() {
  const Vector v1{1, 2, 3};
  Vector v2{4, 5, 6};

  PrintVector(v1);  // Okay, v1 is const
  PrintVector(v2);  // Also okay, v2 is non-const
}
```


```c++
//<o>
Vector: (1, 2, 3)
Vector: (4, 5, 6)
```


If `PrintVector` didn't use `const`, it couldn't accept `v1` as an argument.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'when-to-use-pointers-over-references',
  title: 'When to Use Pointers over References',
  question: 'In what situations should I use pointers instead of references in C++?',
}
```


While references are generally preferred in modern C++, there are still situations where pointers are necessary or more appropriate:

1. When you need to represent the absence of a value. A pointer can be null, while a reference must always refer to an object.
2. When you need to change what a pointer points to. References cannot be reassigned after initialization.
3. When you need to do arithmetic on the address. Pointer arithmetic is not possible with references.
4. When interfacing with legacy code that uses pointers.

Here's an example where a pointer is used to represent the absence of a value:


```c++
#include <iostream>

void Print(const int* ptr) {
  if (ptr) {
    std::cout << "Value: " << *ptr << "\n";
  } else {
    std::cout << "Null pointer\n";
  }
}

int main() {
  int x = 10;
  int* ptr1 = &x;
  int* ptr2 = nullptr;

  Print(ptr1);
  Print(ptr2);
}
```


```text
//<o>
Value: 10
Null pointer
```


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'const-pointers-and-pointers-to-const',
  title: 'Const Pointers and Pointers to Const',
  question: 'What is the difference between a `const` pointer and a pointer to `const`?',
}
```


The placement of `const` in a pointer declaration can be confusing, but it's important to understand the difference:

1. A pointer to const (e.g., `const int*`) is a pointer that points to a const value. You cannot change the value that the pointer points to, but you can change the pointer itself to point to another value.
2. A const pointer (e.g., `int* const`) is a pointer that cannot be changed to point to another value. However, the value that the pointer points to can be changed.

Here's an example:


```c++
int main() {
  int x = 10;
  int y = 20;

  const int* ptr1 = &x;
  // Error: cannot change value through ptr1
  *ptr1 = 30; //<e>
  // Okay: can change to point to another value
  ptr1 = &y;

  int* const ptr2 = &x;
  // Okay: can change value through ptr2
  *ptr2 = 30;
  // Error: cannot change to point to another value
  ptr2 = &y; //<e>
}
```


You can also have a const pointer to a const value (e.g., `const int* const`), which means that neither the pointer nor the value it points to can be changed.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'reference-and-pointer-performance',
  title: 'Reference and Pointer Performance',
  question: 'Is there a performance difference between using references and pointers in C++?',
}
```


In most cases, there is no significant performance difference between using references and pointers. Both references and pointers are essentially just storing memory addresses.


However, there can be some minor differences:

1. References may be easier for the compiler to optimize because they cannot be null and cannot be reassigned. The compiler can make assumptions that it can't make with pointers.
2. Pointers may be slightly faster when it comes to polymorphic behavior and virtual functions, because the compiler can avoid an extra indirection.

But in general, the performance difference is negligible and should not be a major factor in deciding whether to use references or pointers. The choice should be based on the semantics and the requirements of your code.


For example, if a function should not modify its argument and the argument will never be null, a reference to const is a good choice:


```c++
void PrintVector(const Vector& v) {
  std::cout << "Vector: (" << v.x << ", "
    << v.y << ", " << v.z << ")\n";
}
```


But if the function needs to modify its argument or the argument could be null, a pointer would be more appropriate:


```c++
void ScaleVector(Vector* v, float scale) {
  if (v) {
    v->x *= scale;
    v->y *= scale;
    v->z *= scale;
  }
}
```


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'passing-and-returning-references',
  title: 'Passing and Returning References',
  question: 'What should I be aware of when passing or returning references in C++?',
}
```


When passing or returning references in C++, there are a few important things to keep in mind:

1. Avoid returning references to local variables. Local variables are destroyed when the function returns, so returning a reference to a local variable will result in a reference to invalid memory.
2. Be careful when storing a returned reference. If the reference was to a temporary object, that object will be destroyed and the reference will become invalid.
3. Pass by const reference whenever possible to avoid unnecessary copying and to make it clear that the function will not modify the object.

Here's an example of a bad practice - returning a reference to a local variable:


```c++
int& BadFunction() {
  int x = 10;
  // Error: returning reference to local variable
  return x; //<w>
}
```


Instead, you could return by value:


```c++
int GoodFunction() {
  int x = 10;
  return x; // Okay: returning by value
}
```


Or, if you really need to return a reference, make sure it's to a non-local variable:


```c++
int global_x = 10;

int& OkayFunction() {
  // Okay: returning reference to global variable
  return global_x;
}
```


But in general, returning by value is safer and often just as efficient due to compiler optimizations.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'pointer-to-pointer-use-cases',
  title: 'Pointer to Pointer Use Cases',
  question: 'In what situations would I need to use a pointer to a pointer in C++?',
}
```


While pointers to pointers (i.e., `int**`) can be confusing and are often a sign of complex code, there are some situations where they are necessary or useful:

1. When you need to modify a pointer in a function. If you want a function to be able to modify a pointer passed to it, you need to pass a pointer to that pointer.
2. When working with multidimensional arrays. A 2D array is essentially an array of arrays, so a pointer to a 2D array is a pointer to a pointer.
3. When implementing complex data structures like linked lists or trees, where each node contains a pointer to another node.

Here's an example of a function that modifies a pointer:


```c++
#include <iostream>

void AllocateInt(int** ptr) {
  *ptr = new int;  // Allocate memory
  **ptr = 10;      // Set value
}

int main() {
  int* p = nullptr;
  AllocateInt(&p);  // Pass pointer to pointer

  std::cout << "*p = " << *p << "\n";

  delete p;  // Deallocate memory
}
```


```text
//<o>
*p = 10
```


In this case, `AllocateInt` needs to modify the pointer `p` itself (not just the value it points to), so we need to pass a pointer to `p`, which is a pointer to a pointer.


However, pointers to pointers can quickly make code harder to understand and maintain, so they should be used judiciously. Often, there are better alternatives like references, smart pointers, or higher-level abstractions.


</FAQ>



Learn the fundamentals of references, pointers, and the `const` keyword in C++ programming.