Free, Unlimited Access

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

Professional C++





<Excerpt>


Earlier in the course, we introduced the idea of iterators, which generalize the process of traversing through a container.


Rather than writing a function that works with a specific type of container, we can instead write it to work with iterators.


Below, our function template has no notion of containers - it simply  advances an iterator until it reaches the endpoint:


```c++
#include <iostream>

void Log(auto Iterator, auto End) {
  while (Iterator != End) {
    std::cout << *(Iterator++) << ", ";
  }
}
```


Such an algorithm can work with _**any**_ container that provides iterators.


</Excerpt>


Containers typically make iterators available through `begin()` and `end()` methods:


```c++
#include <vector>
#include <forward_list>
#include <iostream>

//<c>
//<l>void Log(auto Iterator, auto End) {/*...*/}
void Log(auto Iterator, auto End) {
  while (Iterator != End) {
    std::cout << *(Iterator++) << ", ";
  }
}
//</c>

int main() {
  std::forward_list List{1, 2, 3};
  std::cout << "std::forward_list<int>:\n";
  Log(List.begin(), List.end());//<h>

  std::vector Vector{1, 2, 3};
  std::cout << "\n\nstd::vector<int>:\n";
  Log(Vector.begin(), Vector.end());//<h>
}
```


```c++
//<o>
std::forward_list<int>:
1, 2, 3,

std::vector<int>:
1, 2, 3,
```


<LessonPromo slug=”iterators” />


This chapter builds on our knowledge of iterators, to unlock even more capabilities.


## What is a Range?


All of the standard library sequential containers we’ve introduced so far, such as `std::vector` and `std::forward_list`, are examples of _**ranges**_.


The concept of a range was introduced in C++20, and is built on the foundations created by iterators.


Similar to iterators, a range establishes a convention on how a type must work for it to be considered a range. 


Specifically, a range is any type that has a `begin()` method that returns an iterator, and an `end()` method that lets us determine when the range ends.


If a type decides to implement that specification, then the type is a range, and can then be used with range-based techniques.


Much of this chapter will be dedicated to exploring those techniques.


## Range-Based For Loops


One of the main techniques that we can apply when working with ranges is the range-based for loop, which we’ve seen a few times in the past.


If a type is a range, then we can use the range-based for-loop syntax to iterate over it:


```c++
#include <vector>
#include <iostream>

int main() {
  std::vector Vector{1, 2, 3};

  for (int x : Vector) {//<h>
    std::cout << x << ", ";//<h>
  }//<h>
}
```


```c++
//<o>
1, 2, 3, 
```


In the next lesson, we’ll see how can update a custom type that we create to satisfy the range requirements, thereby becoming compatible with range-based for loops.


### Passing by (const) Reference


Similar to functions, our objects are passed into the body of our loop by value, meaning they are copied.


If our type is expensive to copy, we will likely want to pass it by reference instead.


Additionally, if we’re not planning to modify the object within the body, we can mark those references as `const`:


```c++
#include <vector>
#include <iostream>

int main() {
  std::vector Vector{1, 2, 3};

  for (const int& x : Vector) {//<h>
    std::cout << x << ", ";
  }
}
```


```c++
//<o>
1, 2, 3, 
```


## Range Categories


In the introduction to iterators, we covered how not all iterators have the same capabilities.  They are broken down into categories, for example:

- A _**forward iterator**_ can only move forward through the collection, one object at a time
- A _**bidirectional iterator**_ can move forward and backward through the collection, one object at a time
- A _**random access iterator**_ can move forward and backward, and by any distance

Given that ranges are built upon iterators, it’s perhaps not surprising that ranges are also separated into categories, based on the capability of the iterator they are based upon.


For example:

- A _**forward range**_, such as a `std::forward_list`, only supports traversal in one direction, one step at a time.
- A _**bidirectional range**_, such as a `std::list`, supports traversal in either direction, one step at a time
- A _**random-access range**_, such as a `std::vector`, allows access to freely jump to any object in the range

Similar to iterator categories, we can imagine ranges existing in a hierarchy, where a more powerful range also meets the requirements of a less powerful range.


For example, a bidirectional range implements all the requirements of a forward range, so it _**is**_ a forward range.


A random-access range implements all the requirements of a bidirectional range, so it _**is**_ a bidirectional range.  And therefore, it is also a forward range.


## Range Concepts


Concepts are available to determine if a type is a valid range.


<LessonPromo slug=”concepts” />


These are available within the `std::ranges` namespace, after including the `<ranges>` header.  For example:

- `std::ranges::forward_range` determines whether a type is a forward range.
- `std::ranges::bidirectional_range` determines whether a type is a bidirectional range
- `std::ranges::random_access_range` determines whether a type is a random access range

Below, we use this to investigate the types our template was instantiated with:


```c++
#include <vector>
#include <list>
#include <forward_list>
#include <ranges>
#include <iostream>

template <typename T>
void Log(T Range) {
  if constexpr (std::ranges::forward_range<T>) {//<h>
    std::cout << " - Forward Range\n";
  }

  if constexpr (
    std::ranges::bidirectional_range<T>//<h>
  ) {
    std::cout << " - Bidirectional Range\n";
  }

  if constexpr (
    std::ranges::random_access_range<T>//<h>
  ) {
    std::cout << " - Random Access Range\n";
  }
}

int main() {
  std::cout << "std::forward_list<int>:\n";
  Log(std::forward_list{1, 2, 3});

  std::cout << "\nstd::list<int>:\n";
  Log(std::list{1, 2, 3});

  std::cout << "\nstd::vector<int>:\n";
  Log(std::vector{1, 2, 3});
}
```


```c++
//<o>
std::forward_list<int>:
 - Forward Range

std::list<int>:
 - Forward Range
 - Bidirectional Range

std::vector<int>:
 - Forward Range
 - Bidirectional Range
 - Random Access Range
```


In this example, we use it to create a template that requires a type to be at least a bidirectional range:


```c++
#include <forward_list>
#include <ranges>
#include <iostream>

void LogLast(
  std::ranges::bidirectional_range auto R//<h>
) {
  std::cout << *(std::next(R.end(), -1));
}

int main() {
  LogLast(std::forward_list{1, 2, 3});//<e>
}
```


```c++
//<oe>
error C2672: 'LogLast': no matching overloaded function found
the associated constraints are not satisfied
the concept 'std::ranges::bidirectional_range<std::forward_list<int>>' evaluated to false
```


## Summary


In this lesson, we explored iterators and ranges, demonstrating how they enable flexible traversal through various container types


### Key Takeaways:

- Iterators provide a generalized way to traverse containers, independent of the container type.
- Functions that work on iterators can operate on any container type that supports iterators, enhancing code reusability.
- Standard containers like `std::vector` and `std::forward_list` offer `begin()` and `end()` methods, making them compatible with iterators.
- The concept of ranges, introduced in C++20, is foundational for types that have `begin()` and `end()` methods.
- Range-based for loops offer a convenient way to iterate over elements in a range.
- Passing objects by (const) reference in range-based for loops can optimize performance, especially for expensive-to-copy objects.
- Ranges are categorized based on the capabilities of their underlying iterators, such as forward, bidirectional, and random-access ranges.
- C++20's range concepts in the `std::ranges` namespace help determine the category of a range.

<FAQ>


```javascript
//<m>
{
  slug: 'how-to-use-iterators',
  title: 'How to Use Iterators in C++',
  question: 'How do I use iterators with different containers in C++?',
}
```


To use iterators with different containers in C++, follow these steps:

1. Include the headers for the containers you plan to use.
2. Use the **`begin()`** and **`end()`** methods to get iterators to the start and end of the container.
3. Use a loop to traverse the container using the iterators.

Here's an example with **`std::vector`** and **`std::forward_list`**:


```c++
#include <vector>
#include <forward_list>
#include <iostream>
void Log(auto Iterator, auto End) {
  while (Iterator != End) {
    std::cout << *(Iterator++) << ", ";
  }
}

int main() {
  std::forward_list<int> List{1, 2, 3};
  std::cout << "std::forward_list<int>:\n";
  Log(List.begin(), List.end());//<h>

  std::vector<int> Vector{1, 2, 3};
  std::cout << "\n\nstd::vector<int>:\n";
  Log(Vector.begin(), Vector.end());//<h>
}
```


```text
//<o>
std::forward_list<int>:
1, 2, 3,

std::vector<int>:
1, 2, 3,
```


</FAQ>
<FAQ>


```javascript
//<m>
{
  slug: 'what-is-a-range',
  title: 'What is a Range in C++?',
  question: 'What is a range in C++ and how is it different from an iterator?',
}
```


A range in C++ is a concept introduced in C++20, representing a sequence of elements with a beginning and an end, defined by **`begin()`** and **`end()`** methods.  The main difference between iterators and ranges are:

- **Iterators**: Provide a way to traverse through elements in a container. They act as pointers to elements.
- **Ranges**: Encompass the entire sequence and provide the **`begin()`** and **`end()`** methods to obtain iterators.

Here's an example:


```c++
#include <vector>
#include <iostream>

int main() {
  std::vector<int> Vector{1, 2, 3};
  
  // Range-based for loop
  for (int x : Vector) { 
    std::cout << x << ", ";
  }
}
```


```text
//<o>
1, 2, 3,
```


In this example, **`Vector`** is a range, and the range-based for loop uses it to iterate over the elements.
</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'range-based-for-loops',
  title: 'Using Range-Based For Loops in C++',
  question: 'How do I use range-based for loops in C++?',
}
```


Range-based for loops provide a simpler syntax for iterating over elements in a range.  Using a range-based for loop involves two steps:

1. **Declare the Loop:** Use the **`for`** keyword followed by the element type, a reference if needed, and the range.
2. **Access Elements:** Inside the loop, you can access each element directly.

Here's an example:


```c++
#include <vector>
#include <iostream>

int main() {
  std::vector<int> Vector{1, 2, 3};

  for (const int& x : Vector) { // Using const reference
    std::cout << x << ", ";
  }
}
```


```text
//<o>
1, 2, 3,
```


Using a reference (**`const int& x`**) avoids copying elements, which is beneficial for large or complex types.
</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'passing-by-reference',
  title: 'Passing by Reference in Range-Based For Loops',
  question: 'Why should I pass by reference in range-based for loops in C++?',
}
```


Passing by reference in range-based for loops is important for efficiency, especially for large or complex types.  The two main benefits of passing by reference are:

- **Avoids Copying**: Passing by reference avoids copying each element, which can be expensive for large objects.
- **Const Safety**: Using **`const`** ensures that elements are not modified accidentally.

Here's an example:


```c++
#include <vector>
#include <iostream>

int main() {
  std::vector<int> Vector{1, 2, 3};

  for (const int& x : Vector) { // Pass by const reference
    std::cout << x << ", ";
  }
}
```


```text
//<o>
1, 2, 3,
```


In this example, **`const int& x`** ensures elements are accessed efficiently and safely.
</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'range-categories',
  title: 'Understanding Range Categories in C++',
  question: 'What are the different categories of ranges in C++?',
}
```


Ranges in C++ are categorized based on the capabilities of their underlying iterators.  There are many different categories of range, each with a different set of capabilities.  The three most common types are:

- **Forward Range**: Supports one-way traversal, such as **`std::forward_list`**.
- **Bidirectional Range**: Supports two-way traversal, such as **`std::list`**.
- **Random-Access Range**: Supports direct access to any element, such as **`std::vector`**.

Here's an example that checks the category of different ranges:


```c++
#include <vector>
#include <list>
#include <forward_list>
#include <ranges>
#include <iostream>

template <typename T>
void Log(T Range) {
  if constexpr (std::ranges::forward_range<T>) {
    std::cout << " - Forward Range\n";
  }
  if constexpr (std::ranges::bidirectional_range<T>) {
    std::cout << " - Bidirectional Range\n";
  }
  if constexpr (std::ranges::random_access_range<T>) {
    std::cout << " - Random Access Range\n";
  }
}

int main() {
  std::cout << "std::forward_list<int>:\n";
  Log(std::forward_list<int>{1, 2, 3});

  std::cout << "\nstd::list<int>:\n";
  Log(std::list<int>{1, 2, 3});

  std::cout << "\nstd::vector<int>:\n";
  Log(std::vector<int>{1, 2, 3});
}
```


```text
//<o>
std::forward_list<int>:
 - Forward Range

std::list<int>:
 - Forward Range
 - Bidirectional Range

std::vector<int>:
 - Forward Range
 - Bidirectional Range
 - Random Access Range
```


</FAQ>
<FAQ>


```javascript
//<m>
{
  slug: 'concepts-in-cpp',
  title: 'Using Concepts in C++',
  question: 'How do I use concepts in C++ to check if a type is a range?',
}
```


Concepts in C++20 allow us to define requirements that types must satisfy.  To determine if an object is a valid range using C++20 concepts, there are two steps:

1. **Include** **`<ranges>`** **Header:**  Standard library concepts for testing ranges are in the `std::ranges` namespace.
2. **Check Range Type:** Use concepts like `std::ranges::forward_range` to determine the category.

Here's an example:


```c++
#include <vector>
#include <list>
#include <forward_list>
#include <ranges>
#include <iostream>

template <typename T>
void Log(T Range) {
  if constexpr (std::ranges::forward_range<T>) {
    std::cout << " - Forward Range\n";
  }
  if constexpr (std::ranges::bidirectional_range<T>) {
    std::cout << " - Bidirectional Range\n";
  }
  if constexpr (std::ranges::random_access_range<T>) {
    std::cout << " - Random Access Range\n";
  }
}

int main() {
  std::cout << "std::forward_list<int>:\n";
  Log(std::forward_list<int>{1, 2, 3});

  std::cout << "\nstd::list<int>:\n";
  Log(std::list<int>{1, 2, 3});

  std::cout << "\nstd::vector<int>:\n";
  Log(std::vector<int>{1, 2, 3});
}
```


```text
//<o>
std::forward_list<int>:
 - Forward Range

std::list<int>:
 - Forward Range
 - Bidirectional Range

std::vector<int>:
 - Forward Range
 - Bidirectional Range
 - Random Access Range
```


Concepts simplify template programming by providing clear requirements for types.
</FAQ>



This lesson offers an in-depth look at iterators and ranges, emphasizing their roles in container traversal

How to Use Iterators in C++

What is a Range in C++?

Using Range-Based For Loops in C++

Passing by Reference in Range-Based For Loops

Understanding Range Categories in C++

Using Concepts in C++

Iterator Definitions and Categories in C++

Iterator library

Ranges library (C++20)

Defining C++ Iterators for New Containers

Comprehensive Guide on C++ Iterators

UPDATED FOR C++23 | An in-depth look at iterators and ranges in C++, and their roles in container traversal | Clear explanations and simple code examples

How to Use Iterators in C++

How do I use iterators with different containers in C++?

Iterators and Ranges

What is a range in C++ and how is it different from an iterator?

How do I use range-based for loops in C++?

Why should I pass by reference in range-based for loops in C++?

What are the different categories of ranges in C++?

How do I use concepts in C++ to check if a type is a range?

Iterators and Ranges

Professional C++

This course includes:

Professional C++