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. We will need to use that collection to generate other collections:

• Our user collection, sorted by how active each user has been in the past month
• A subset containing only the users that are online right now
• A collection showing the number of users in each country

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 in a different way. In C++ this new object would be a view.

Creating Views

Views are easier to explain with an example.

The views we’ll be using in this lesson are available from the <ranges> header:

1#include <ranges>
2

The most basic view we can create is simply a view of all our data, using std::views::all:

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

112345
2

This helps us demonstrate some of the key properties of views

Firstly, a view is a range. Among other things, that means that they can be used with range-based algorithms and range-based for loops, as shown above.

Secondly, views are generated on demand, at the point they are used. One of the impacts of this is shown below:

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

1123456
2

We added another entry to our collection after the view was created. However, when we came to use the view, that new entry was included. This shows that the view maintains a connection to the underlying data structure from which it was created.

1Numbers[0] = 100;
2std::cout << View[0];
3

1100
2

Standard Library Views

Let's see some other examples of views that are included in the standard library

std::views::reverse

We can create a view of the elements in reverse order, using std::views::reverse:

1std::vector Numbers { 1, 2, 3, 4, 5 };
2
3for (const auto& Num :
4  std::views::reverse(Numbers)
5) {
6  std::cout << Num;
7}
8

154321
2

std::views::take

If we want to create a view of the initial elements of the collection, we can use std::views::take. We pass in the collection and the number of items we want to include. In this example, we take 3:

1std::vector Numbers{ 1, 2, 3, 4, 5 };
2
3for (const auto& Num :
4  std::views::take(Numbers, 3)
5) {
6  std::cout << Num;
7}
8

1123
2

std::views::drop

The std::views::drop function lets us create a view with the initial elements removed. In this case, we remove the first two elements:

1std::vector Numbers { 1, 2, 3, 4, 5 };
2
3for (const auto& Num :
4  std::views::drop(Numbers, 2)
5) {
6  std::cout << Num;
7}
8

1345
2

std::views::filter

The std::views::filter function passes each element into a predicate function. If the function returns true for that element, it gets included in the view. In this example, we create a view of only the odd numbers:

1std::vector Numbers { 1, 2, 3, 4, 5 };
2  
3auto FilteredView {
4  std::views::filter(Numbers, [](int i){
5    return i % 2 == 1;
6  })
7};
8
9for (const auto& Num : FilteredView) {
10  std::cout << Num;
11}
12

1135
2

std::views::transform

The std::views::transform function passes each element into a transformation function. The view is then created from the return value of each of those function calls. In this example, we create a view by doubling the input values:

1std::vector Numbers { 1, 2, 3, 4, 5 };
2
3auto TransformedView {
4  std::views::transform(Numbers, [](int i){
5    return i * 2;
6  })
7};
8
9for (const auto& Num : TransformedView) {
10  std::cout << Num << ",";
11}
12

12,4,6,8,10,
2

Note that this does not modify the values in the original collection. It just creates a view of that data, having been passed through the transformer.

Additionally, the transformer does not need to return the same type of data as the original collection. Below, the source collection containers numbers, but the transformed view displays strings:

1std::vector Numbers { 0, 1, 2, 3, 4 };
2std::vector Weekdays { "Mon", "Tue", "Wed", "Thu", "Fri" };
3
4auto TransformedView { std::views::transform(
5  Numbers,
6  [&Weekdays](int i){
7    return Weekdays[i];
8  }
9)};
10
11for (const auto& Day : TransformedView) {
12  std::cout << Day << " ";
13}
14

1Mon Tue Wed Thu Fri
2

Sequencing Views

Views can be chained together using the | operator. For example, this code takes the first 3 elements, filters to only include the odd numbers, and then reverses that view.

1std::vector Numbers { 1, 2, 3, 4, 5 };
2
3auto View {
4  std::views::take(Numbers, 3) |
5  std::views::filter(
6    [](int i){
7      return i % 2 == 1;
8    }) |
9  std::views::reverse
10};
11
12for (const auto& Num : View) {
13  std::cout << Num << " ";
14}
15

13 1
2

Something to note when chaining views in this way: only the first function needs to be provided with the original data.

In the above example, std::views::filter when used by itself requires the original data but, when chained with a preceding view, it will use that data instead. So, we only need to pass one argument - the predicate function.

Equally, std::views::reverse will get the data from the preceding view, so it doesn’t need any arguments at all. In this scenario, the standard library is implemented such that we don’t even need the () - we just chain std::views::reverse.

Using Views in Range-Based For Loops

Views are also ranges, which means we can use them in range-based for loops. Below, we are using a view to iterate only the first 3 elements of our collection:

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

11, 2, 3,
2

Zip Views

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

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  for (const auto& Tuple :
16       std::views::zip(Numbers, English,
17                       French)) {
18    std::cout << std::get<0>(Tuple) << ". ";
19    std::cout << std::get<1>(Tuple) << ": ";
20    std::cout << std::get<2>(Tuple) << '\n';
21  }
22}
23

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

We cover tuples in more detail here:

Tuples and std::tuple

A guide to tuples in C++, using the std::tuple container. Tuples allow us to store any number of objects, and those objects can have different types.

Iota Views

In the previous example, we created a vector to store a collection of incrementing numbers. This wasn’t necessary - we have a standard library view for this: 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, eg $1, 2, 3, 4, 5$

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

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

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

Infinitely long 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}
10

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

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 Strings{"One", "Two", "Three"};
8
9  for (const auto& Tuple :
10       zip(iota(1), Strings)) {
11    std::cout << std::get<0>(Tuple) << ": ";
12    std::cout << std::get<1>(Tuple) << '\n';
13  }
14}
15

11: One
22: Two
33: Three
4

Modifying the Original Elements using the View

We can use our view to modify elements in the original collection. For example, here we create a view comprising only the even numbers in our collection. Then, we use that view to set those numbers to 0:

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

11 0 3 0 5
2

A Practical Example

In this example, we create a view that we can use to see which members of our party are dead. We can also use that view to perform actions on all the dead party members:

1#include <vector>
2#include <iostream>
3#include <ranges>
4
5using std::cout, std::string;
6
7class Character {
8public:
9  Character(string Name, int Health) :
10    Name(std::move(Name)),
11    Health(Health) {};
12
13  bool isDead() const { return Health <= 0; }
14  void Revive() {
15    cout << "Reviving " << GetName() << "\n";
16    Health = 1;
17  }
18  string GetName() const { return Name; }
19  int GetHealth() const { return Health; }
20
21private:
22  string Name;
23  int Health;
24};
25
26void LogParty(auto& Party) {
27  cout << "\nParty Status:\n";
28  for (const auto& Character : Party) {
29    cout << "[" << Character.GetHealth() << "] "
30              << Character.GetName() << "\n";
31  }
32  cout << "\n";
33}
34
35int main() {
36  std::vector Party {
37    Character {"Legolas", 0},
38    Character {"Gimli", 100},
39    Character {"Gandalf", 0}
40  };
41
42  auto DeadPartyMembers {
43    std::views::filter(
44      Party,
45      &Character::isDead
46    )
47  };
48
49  cout << "Party Status:\n";
50  LogParty(Party);
51
52  cout << "Dead Members:\n";
53  LogParty(DeadPartyMembers);
54
55  for (auto& Character : DeadPartyMembers) {
56    Character.Revive();
57  }
58
59  cout << "\nNew Party Status:\n";
60  LogParty(Party);
61}
62

1Party Status:
2[0] Legolas
3[100] Gimli
4[0] Gandalf
5
6Dead Members:
7[0] Legolas
8[0] Gandalf
9
10Reviving Legolas
11Reviving Gandalf
12
13New Party Status:
14[1] Legolas
15[100] Gimli
16[1] Gandalf
17