Standard Library Views

When we have a collection of data, it is often useful to be able to create and work on subsets or derivatives of that data. For example, let's imagine we have a large collection of User objects in a std::vector.

Often, the tasks our program needs to perform will require filtering or processing the collection in some way. For example, we might need to act on:

• Only the subset of users that are online right now
• A random sample of users
• A collection that combines each User object with the Organisation object that the user is part of

We could create these aggregations using loops and other techniques we’ve already covered. But, if we do that, our aggregations fall out of date as soon as something changes in our original collection of users.

Instead, it is preferable to create an object that maintains its connection to the original data structure. Our new object just presents that collection differently. In C++ this new object would be a view.

Creating Views

The standard library views are available within the <ranges> header:

1#include <ranges>

One of the most basic standard library views is std::views::take(), which shows the initial objects in a range. We pass it two arguments: the range we want to view and how many objects we want to view from that range.

Below, we create a view of the first 3 objects:

1#include <ranges>
2#include <vector>
3
4int main() {
5  std::vector Numbers{1, 2, 3, 4, 5};
6  auto View{std::views::take(Numbers, 3)};  
7}

Views are Ranges

The main benefit of views is that they are, themselves, ranges. This makes them compatible with range-based techniques.

Example: Range Based For Loop

Because views are ranges, we can use them with range-based for loops. Below, we use a view from std::views::take() to iterate through the first three elements of our range:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main() {
6  using std::views::take;
7  std::vector Numbers{1, 2, 3, 4, 5};
8
9  for (const auto& Num : take(Numbers, 3)) {  
10    std::cout << Num << ", ";     
11  }                               
12}

11, 2, 3,

Example: Ranged-Based Algorithm

Views are also compatible with range-based algorithms. Below, we use std::views::reverse() to create a view of our collection in reverse. We then pass this view to std::ranges::for_each() - a range-based algorithm:

1#include <iostream>
2#include <ranges>
3#include <vector>
4#include <algorithm>
5
6void Log(int x) {
7  std::cout << x << ", ";
8}
9
10int main() {
11  std::vector Numbers{1, 2, 3, 4, 5};
12
13  std::ranges::for_each(
14    std::views::reverse(Numbers), Log);
15}

15, 4, 3, 2, 1,

Views are "Non-Owning"

The second important concept to understand about views is that they do not "own" the data they’re accessing. When we access an object through a view, we are accessing the object within the memory address managed by the container the view is based on.

This has two implications. First, views are fast to create, as they do not need to copy any of the underlying data.

Secondly, changes we make through the view will affect the original container. Below, we sort the first 3 objects in our container using a view:

1#include <iostream>
2#include <ranges>
3#include <vector>
4#include <algorithm>
5
6int main() {
7  std::vector Numbers{4, 1, 3, 2, 5};
8
9  std::ranges::sort(
10    std::views::take(Numbers, 3));
11
12  for (const auto& Num : Numbers) {
13    std::cout << Num << ", ";
14  }
15}

11, 3, 4, 2, 5,

The opposite is also true - if something changes in our original collection, that change will be reflected in any views that use the container:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main() {
6  std::vector Numbers{4, 1, 3, 2, 5};
7  auto View{std::views::take(Numbers, 3)};
8
9  std::cout << "View[0]: " << View[0];
10  Numbers[0] = 100;
11  std::cout << "\nView[0]: " << View[0];
12}

1View[0]: 4
2View[0]: 100

Filtering Objects using a View

One of the most common use cases for views is to create a range that only includes a subset of the original collection based on some predicate function.

The standard library’s std::views::filter() function can help us with this. We pass our range as the first argument and a predicate function as the second. Every object for which the predicate returns true is included in the view.

In this example, we create a view of only the odd numbers:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main() {
6  std::vector Numbers { 1, 2, 3, 4, 5 };
7
8  auto FilteredView {
9    std::views::filter(Numbers, [](int i){
10      return i % 2 == 1;
11    })
12  };
13
14  for (const auto& Num : FilteredView) {
15    std::cout << Num << ", ";
16  }
17}

11, 3, 5,

Below, we have a Party class, acting as a container for Player objects. Our class implements a DeadPlayers() method to give convenient access to just a subset of its elements:

1#include <vector>
2#include <iostream>
3#include <ranges>
4#include <print>
5
Player Class|Show
6class Player {/*...*/}
26
27class Party {
28 public:
Log Function|Show
29  void Log() {/*...*/}
37
38  void Revive() {
39    for (auto& P : DeadPlayers()) {
40      P.Revive();
41    }
42    std::cout << '\n';
43  }
44
45private:
46  auto DeadPlayers() {
47    return std::views::filter(
48      Players, &Player::isDead);
49  }
50
51  std::vector<Player> Players{
52    Player{"Legolas", 0},
53    Player{"Gimli", 100},
54    Player{"Gandalf", 0}
55  };
56};
57
58int main() {
59  Party Players;
60  Players.Log();
61  Players.Revive();
62  Players.Log();
63}

1[0] Legolas
2[100] Gimli
3[0] Gandalf
4
5Reviving Legolas
6Reviving Gandalf
7
8[1] Legolas
9[100] Gimli
10[1] Gandalf

Composition and Pipelines

Because views are ranges, and views are also created from ranges, this allows them to be composed. That is, the output of one view can become the input of another view.

Below, we create a view composed of three simpler views:

1. We filter the collection to only contain the odd numbers
2. We take the first 3 results returned by view 1
3. We reverse the results of view 2

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5bool Filter(int x) {
6  return x % 2 == 1;
7}
8
9int main() {
10  std::vector Numbers { 1, 2, 3, 4, 5, 6, 7 };
11
12  auto View {
13    std::views::reverse(
14      std::views::take(
15        std::views::filter(Numbers, Filter),
16      3)
17    )
18  };
19
20  for (const auto& Num : View) {
21    std::cout << Num << ", ";
22  }
23}

15, 3, 1,

Creating Pipelines using the Pipe Operator: |

The ranges library provides an alternative syntax to make the composition more succinct. The objects returned from views overload the | operator specifically for composition.

As such, the previous example could be written like this:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5bool Filter(int x) {
6  return x % 2 == 1;
7}
8
9int main() {
10  std::vector Numbers { 1, 2, 3, 4, 5, 6, 7 };
11
12  auto View {
13    std::views::filter(Numbers, Filter) |
14    std::views::take(3) |
15    std::views::reverse
16  };
17
18  for (const auto& Num : View) {
19    std::cout << Num << ", ";
20  }
21}

15, 3, 1,

Something to note when creating pipelines is that the API has been set up to be as succinct as possible, reducing the amount of syntax we need. Therefore, only the first function in the sequence is provided with the original range. Any subsequent function in the pipeline uses the return value of the previous function as its input.

For example, std::views::take() would normally receive two arguments - the range and the quantity to take. But above, it is used as the right operand of the previous view’s | operator. In this context, the API is set up so the range it will view is coming from that left operand, so we only need to provide the integer argument - 3, in this example.

Equally, std::views::reverse() would normally require us to provide the range but, within a pipeline, it’s coming from the previous function. Therefore, std::views::reverse() in this context requires no arguments at all.

Additionally, the API has been set up such that if a view requires no arguments, we don’t even need to use the () operator.

1FunctionC(
2  FunctionB(
3    FunctionA(Input)
4  )
5);

1Input
2|> FunctionA
3|> FunctionB
4|> FunctionC

1FunctionA(Input)
2| FunctionB
3| FunctionC

Zip Views

std::views::zip() allows us to combine multiple ranges (including views) into a single view. Each element in the zipped view is a tuple, containing parallel elements from each of the input views.

Below, we zip three ranges to create a view called TranslationView. Every element of TranslationView is a tuple containing an element from each of the input ranges.

In this case, each tuple has an integer from Numbers, a string from English, and another string from French:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main(){
6  std::vector Numbers{1, 2, 3, 4, 5, 6, 7};
7  std::vector English{
8    "Monday", "Tuesday", "Wednesday",
9    "Thursday",
10    "Friday", "Saturday", "Sunday"};
11  std::vector French{
12    "Lundi", "Mardi", "Mercredi", "Jeudi",
13    "Vendredi", "Samedi", "Dimanche"};
14
15  auto TranslationView{std::views::zip(
16    Numbers, English, French)};
17
18  for (const auto& Tuple : TranslationView) {
19    std::cout << std::get<0>(Tuple) << ". "
20              << std::get<1>(Tuple) << ": "
21              << std::get<2>(Tuple) << '\n';
22  }
23}

11. Monday: Lundi
22. Tuesday: Mardi
33. Wednesday: Mercredi
44. Thursday: Jeudi
55. Friday: Vendredi
66. Saturday: Samedi
77. Sunday: Dimanche

We cover tuples in more detail here:

Tuples and std::tuple

A guide to tuples and the std::tuple container, allowing us to store objects of different types.

Range Factories

Some views can be created without requiring an underlying container. These are called range factories, as they can generate views (which are ranges) algorithmically.

Example: std::views::iota()

Iota is the 9th letter of the Greek alphabet, $\iota$, and in programming contexts, is sometimes used to refer to a sequence of incrementing integers, e.g., $1, 2, 3, 4, 5$

One of the most useful range factories is std::view::iota(), which simply creates a view of incrementing integers.

std::views::iota() accepts two arguments - the first and last numbers in the sequence. The view then contains every integer from the first argument, up to (but not including) the second argument:

1#include <iostream>
2#include <ranges>
3
4int main(){
5  for (int x : std::views::iota(1, 11)) {
6    std::cout << x << ", ";
7  }
8}

11, 2, 3, 4, 5, 6, 7, 8, 9, 10,

The second argument is optional, thereby creating an unbounded view.

1#include <iostream>
2#include <ranges>
3
4int main() {
5  // Infinite loop
6  for (int x : std::views::iota(1)) {
7    std::cout << x << ", ";
8  }
9}

Infinite sequences are not practically useful, so they are only used in scenarios where they’re being constrained in some other way. A simple example of this is given below, where we limit the output using std::views::take():

1#include <iostream>
2#include <ranges>
3
4int main(){
5  using std::views::iota, std::views::take;
6  for (int x : iota(1) | take(10)) {
7    std::cout << x << ", ";
8  }
9}

11, 2, 3, 4, 5, 6, 7, 8, 9, 10,

Below, we use an unbounded iota with std::views::zip() to create a numbered list, based on a different collection:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main(){
6  using std::views::iota, std::views::zip;
7  std::vector Nums{"One", "Two", "Three"};
8
9  for (const auto& Tuple : zip(iota(1), Nums)) {
10    std::cout << std::get<0>(Tuple) << ": ";
11    std::cout << std::get<1>(Tuple) << '\n';
12  }
13}

11: One
22: Two
33: Three

Summary

In this lesson, we explored how views offer a powerful, efficient way to work with data ranges without owning or copying them. Through various examples, we demonstrated how views can be used to create subsets, perform transformations, and compose complex data processing pipelines with minimal overhead.

Main Points Learned

• The concept of views in C++ and their advantage of not owning data, allowing for efficient data manipulation.
• How to create views using standard library utilities such as std::views::take.
• Understanding that views are ranges themselves and can be used with range-based for loops and algorithms.
• The non-owning nature of views means changes to the original data or through the view are reflected across both.
• The use of std::views::filter to create views that only include elements matching a predicate function.
• Composition of views using the pipe operator | to build more complex data processing operations.
• Introduction to range factories like std::views::iota for generating sequences of numbers without a backing container.
• The concept of zip views with std::views::zip for combining multiple ranges into a single view where elements are tuples of elements from each input range.

Next Lesson

Creating Views using std::ranges::subrange

This lesson introduces std::ranges::subrange, allowing us to create non-owning ranges that view some underlying container

ContinueView Course