Creating Views using `std::ranges::subrange`

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

This lesson is part of the course:

Professional C++

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

Free, Unlimited Access

Ryan McCombe

Posted 2 months ago

When we want to create a non-owning view of some underlying container, the std::ranges::subrange type within <ranges> is what we typically use.

This lesson will provide a thorough overview of this type - how to create them, how to use them, and how to combine them with many of the other features we’ve introduced earlier in the chapter.

Creating Subranges

The std::ranges::subrange template is available within the <ranges> header. The simplest constructor it accepts a source range to base the view upon. Below, we create a view of our Nums range:

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

As always, we can define our range as an iterator-sentinel pair instead. Here, we create a view of the middle three elements of our range:

1#include <ranges>
2#include <vector>
3
4int main() {
5  std::vector Nums{1, 2, 3, 4, 5};
6  std::ranges::subrange View{
7    Nums.begin() + 1, Nums.end() -1};
8}

Using Subranges

Like other views, subranges are themselves ranges. Most of the ways in which we need to use a subrange involve using range-based techniques. Below, we use a range-based for loop:

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

11, 2, 3, 4, 5,

In the following example, we apply a range-based algorithm to our subrange:

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

11, 2, 3, 4, 5,

We can use our subrange to create another view, using std::views::reverse for example:

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

15, 4, 3, 2, 1,

Subranges are a View

Like other views, subranges are non-owning types. When accessing objects through a view, we are accessing memory locations owned by some other container.

This makes subranges fast to create and copy, but also means changes made through the subrange impact the underlying container. Below, we sort our subrange, and then log the contents of our original container to show the effect:

1#include <algorithm>
2#include <iostream>
3#include <ranges>
4#include <vector>
5
6void Log(int x) { std::cout << x << ", "; }
7
8int main() {
9  std::vector Nums{3, 1, 5, 2, 4};
10
11  std::cout << "Nums: ";
12  std::ranges::for_each(Nums, Log);
13
14  std::ranges::subrange View{Nums};
15  std::ranges::sort(View);
16  std::cout << "\nNums: ";
17  std::ranges::for_each(Nums, Log);
18}

1Nums: 3, 1, 5, 2, 4,
2Nums: 1, 2, 3, 4, 5,

Similarly, changes made to the source range are reflected in the view:

1#include <algorithm>
2#include <iostream>
3#include <ranges>
4#include <vector>
5
6void Log(int x) { std::cout << x << ", "; }
7
8int main() {
9  std::vector Nums{3, 1, 5, 2, 4};
10
11  std::ranges::subrange View{Nums};
12  std::cout << "View: ";
13  std::ranges::for_each(View, Log);
14
15  std::ranges::sort(Nums);
16  std::cout << "\nView: ";
17  std::ranges::for_each(View, Log);
18}

1View: 3, 1, 5, 2, 4,
2View: 1, 2, 3, 4, 5,

Below, we compose a std::ranges::subrange with other views into a pipeline:

1#include <iostream>
2#include <ranges>
3#include <vector>
4#include <algorithm>
5
6bool isEven(int x) { return x % 2 == 0; }
7void Log(int x) { std::cout << x << ", "; }
8
9int main() {
10  using std::ranges::subrange;
11  std::vector Nums{1, 2, 3, 4, 5, 6, 7};
12
13  auto Pipeline{
14    subrange(Nums.begin() + 1, Nums.end() - 1)
15    | std::views::filter(isEven)
16    | std::views::reverse
17  };
18
19  std::ranges::for_each(Pipeline, Log);
20}

16, 4, 2,

Sized Ranges

Often, we can determine the number of objects in our subrange view using the size() method:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main() {
6  std::vector Nums{1, 2, 3};
7  std::ranges::subrange Subrange{Nums};
8  std::cout << "Size: " << Subrange.size();
9}

1Size: 3

However, this is not always available. For example, if we attempt to retrieve the size() of a subrange based on a std::forward_list, we will generate a compiler error:

1#include <iostream>
2#include <forward_list>
3#include <ranges>
4
5int main() {
6  std::forward_list Nums{1, 2, 3};
7  std::ranges::subrange Subrange{Nums};
8  std::cout << "Size: " << Subrange.size();
9}

1error C7500: 'size': no function satisfied its constraints

Specifically, the size() method requires that our subrange must be able to determine its size in constant time.

Ranges generated from an array like std::vector will often be able to do this, but it’s less likely for ranges based on linked lists, for example.

If ideas like "constant time" and the differences between arrays and linked lists are unfamiliar, we covered these topics earlier in the course:

3D art showing a woman in a cyberpunk character

Algorithm Analysis and Big O Notation

An introduction to algorithms - the foundations of computer science. Learn how to design, analyze, and compare them.

Data Structures and Algorithms

This lesson introduces the concept of data structures beyond arrays, and why we may want to use alternatives.

We can check if our range meets the requirements using the std::ranges::sized_range concept:

1#include <iostream>
2#include <vector>
3#include <forward_list>
4#include <ranges>
5
6template <typename T>
7void LogSized(T Range) {
8  if constexpr (std::ranges::sized_range<T>) {
9    std::cout << "\nThat range is sized: "
10      << Range.size();
11  } else {
12    std::cout << "\nThat range is not sized";
13  }
14}
15
16int main() {
17  std::vector NumsA{1, 2, 3};
18  LogSized(std::ranges::subrange{NumsA});
19
20  std::forward_list NumsB{1, 2, 3};
21  LogSized(std::ranges::subrange{NumsB});
22}

1That range is sized: 3
2That range is not sized

Illustration representing computer hardware

Concepts in C++20

Learn how to use C++20 concepts to constrain template parameters, improve error messages, and enhance code readability.

Size Hints

If we know the size our subrange will be when we create it, we can optionally provide that to the subrange constructor. This is referred to as a size hint, and it allows our subrange to be a sized_range even if the container it is viewing is not sized.

Below, we pass a size hint of 3:

1#include <forward_list>
2#include <iostream>
3#include <ranges>
4
5void LogSized(T Range) {/*...*/}
15
16int main() {
17  std::forward_list Range{1, 2, 3};
18  LogSized(Range);
19
20  std::ranges::subrange Subrange{Range, 3};  
21  LogSized(Subrange);
22}

1That range is not sized
2That range is sized: 3

The compiler assumes the size hint we provide is accurate. If the value we provide is incorrect, the behaviour becomes undefined.

Using `std::distance()`

We can still determine the size of any range by passing the iterator and sentinel to the std::distance() function. This is available even if the range is not a sized_range:

1#include <forward_list>
2#include <iostream>
3
4int main() {
5  std::forward_list Range{1, 2, 3};
6  std::cout << "Size: " <<
7    std::distance(Range.begin(), Range.end());
8}

1Size: 3

However, unlike the size() method (or std::size()), this approach is not guaranteed to be a fast, constant-time operation. Calculating the distance may require traversal through the range:

We covered std::distance() and similar functions in our introductory lesson on iterators:

Iterators

This lesson provides an in-depth look at iterators in C++, covering different types like forward, bidirectional, and random access iterators, and their practical uses.

The `empty()` method

In most scenarios, we can determine if the size of our range is 0 by calling the more descriptive empty() method:

1#include <vector>
2#include <iostream>
3
4int main() {
5  std::vector Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  if (!Subrange.empty()) {
9    std::cout << "Subrange is not empty";
10  }
11}

1Subrange is not empty

This is also available simply by using the range as a bool:

1#include <vector>
2#include <iostream>
3
4int main() {
5  std::vector Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  if (Subrange) {
9    std::cout << "Subrange is not empty";
10  }
11}

1Subrange is not empty

Traversal

In this section, we cover some of the main ways we traverse through our subranges.

Using `begin()` and `end()`

The subrange’s iterator and sentinel are available through the begin() and end() methods respectively. This allows us to use all the usual iterator-based techniques on our range.

Below, we use these with std::for_each(), an iterator based algorithm:

1#include <iostream>
2#include <vector>
3#include <algorithm>
4
5void Log(int x) { std::cout << x << ", "; }
6
7int main() {
8  std::vector Range{1, 2, 3, 4, 5};
9  std::ranges::subrange A{Range};
10
11  std::for_each(A.begin(), A.end(), Log);
12}

11, 2, 3, 4, 5,

The std::ranges::subrange type also supports structured binding, giving us an alternative way to access the objects that represent the start and end of the subrange:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5void Log(int x) { std::cout << x << ", "; }
6
7int main() {
8  std::vector Range{1, 2, 3, 4, 5};
9  std::ranges::subrange A{Range};
10
11  auto [begin, end]{A};
12
13  std::for_each(begin, end, Log);
14}

11, 2, 3, 4, 5,

3D art showing a fantasy pirate character

Structured Binding

This lesson introduces Structured Binding, a handy tool for quickly unpacking simple data structures

The `advance()` Method

We can advance the iterator within our subrange using the advance() method, which accepts an argument for how many steps we want to move the iterator forward. Below, we advance our subrange by 2 steps:

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3, 4, 5};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "Subrange: ";
9  for (auto x : Subrange) {
10    std::cout << x << ", ";
11  }
12
13  Subrange.advance(2);
14  std::cout << "\nAfter advancing: ";
15  for (auto x : Subrange) {
16    std::cout << x << ", ";
17  }
18}

1Subrange: 1, 2, 3, 4, 5,
2After advancing: 3, 4, 5,

The advance() method will not advance our iterator past the end of our subrange. Below, we attempt to advance 100 steps, but we only advance as far as the sentinel:

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3, 4, 5};
6  std::ranges::subrange Subrange{Range};
7
8  Subrange.advance(100);
9  if (Subrange.begin() == Subrange.end()) {
10    std::cout << "We advanced to the end"
11      << "\nSubrange Size: " << Subrange.size();
12  }
13}

1We advanced to the end
2Subrange Size: 0

If our range is at least bidirectional, we can pass a negative offset to advance():

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3, 4, 5};
6  std::ranges::subrange Subrange{
7    Range.begin() + 3, Range.end()};
8
9  std::cout << "Subrange: ";
10  for (auto x : Subrange) {
11    std::cout << x << ", ";
12  }
13
14  Subrange.advance(-3);
15  std::cout << "\nAfter advancing backwards: ";
16  for (auto x : Subrange) {
17    std::cout << x << ", ";
18  }
19}

1Subrange: 4, 5,
2After advancing backwards: 1, 2, 3, 4, 5,

Unlike when advancing forward, there are no checks preventing us from "advancing" too far. For example, we should ensure our call to advance() doesn’t move the iterator backwards beyond the beginning of the container.

The `next()` Method

The next() method works similarily to advance(). However, rather than modifing our subrange in place, next() instead returns a new subrange.

This new subrange will have its pointer advanced, whilst the subrange we called the method on will not be modified:

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3, 4, 5};
6  std::ranges::subrange A{Range};
7  std::ranges::subrange B{A.next(2)};
8
9  std::cout << "A: ";
10  for (auto x : A) {
11    std::cout << x << ", ";
12  }
13
14  std::cout << "\nB: ";
15  for (auto x : B) {
16    std::cout << x << ", ";
17  }
18}

1A: 1, 2, 3, 4, 5,
2B: 3, 4, 5,

Negative offsets and `prev()`

As with advance(), if our subrange is bidirectional, we can pass a negative offset to the next() method. This causes the function to return a view that contains more objects than the subrange it was called upon:

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3, 4, 5};
6  std::ranges::subrange A{
7    Range.begin() + 2, Range.end()};
8
9  // Not recommended - see note below
10  std::ranges::subrange B{A.next(-2)};
11
12  std::cout << "A: ";
13  for (auto x : A) {
14    std::cout << x << ", ";
15  }
16
17  std::cout << "\nB: ";
18  for (auto x : B) {
19    std::cout << x << ", ";
20  }
21}

1A: 3, 4, 5,
2B: 1, 2, 3, 4, 5,

However, if we know we’re moving the iterator backwards (that is, the argument we’re passing to next() will be negative) we should prefer the prev() method with a positive argument instead:

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3, 4, 5};
6  std::ranges::subrange A{
7    Range.begin() + 2, Range.end()};
8  std::ranges::subrange B{A.prev(2)};
9
10  std::cout << "A: ";
11  for (auto x : A) {
12    std::cout << x << ", ";
13  }
14
15  std::cout << "\nB: ";
16  for (auto x : B) {
17    std::cout << x << ", ";
18  }
19}

1A: 3, 4, 5,
2B: 1, 2, 3, 4, 5,

This makes our intent clearer, and enables additional compile-time checks. For example, prev() will ensure our range supports reverse traversal, by checking that it is bidirectional. If it’s not, we get a compiler error rather than a potential bug:

1#include <forward_list>
2
3int main() {
4  std::forward_list Range{1, 2, 3, 4, 5};
5  std::ranges::subrange Subrange{
6    std::next(Range.begin(), 2), Range.end()};
7
8  Subrange.prev(2);
9}

1error: 'prev': no function satisfied its constraints
2the concept 'std::bidirectional_iterator' evaluated to false

Object Access

In this section, we cover the main ways we can access the objects within our container, through the subrange that is viewing it.

Iterator Techniques

As with any iterators, we can access the object they’re pointing at by dereferencing them. Below, we access the first element using the iterator returned from begin():

1#include <forward_list>
2#include <iostream>
3
4int main() {
5  std::forward_list Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "First: " << *Subrange.begin();
9}

1First: 1

We can also the begin() method alongside iterator techniques such as std::next() to access objects based on an offset from the front:

1#include <forward_list>
2#include <iostream>
3
4int main() {
5  std::forward_list Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "Third: "
9    << *std::next(Subrange.begin(), 2);
10}

1Third: 3

When our view is at least a bidirectional range, we can use std::prev() to create an iterator by moving backwards through the range:

1#include <list>
2#include <iostream>
3
4int main() {
5  std::list Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "First: "
9    << *std::prev(Subrange.end(), 3);
10}

1First: 1

The `front()` Method

When we explicitly want to access the object at the start of our view, we can use the front() method:

1#include <iostream>
2#include <forward_list>
3
4int main() {
5  std::forward_list Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "Front: " << Subrange.front();
9}

1Front: 1

The `back()` Method

If our view is at least a bidirectional range, we can access the object at the end of the range using the back() method:

1#include <iostream>
2#include <list>
3
4int main() {
5  std::list Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "Back: " << Subrange.back();
9}

1Back: 3

The `[]` Operator

When our range supports random access, we can access the object at any position using the [] operator:

1#include <iostream>
2#include <vector>
3
4int main() {
5  std::vector Range{1, 2, 3};
6  std::ranges::subrange Subrange{Range};
7
8  std::cout << "Index 1: " << Subrange[1];
9}

1Index 1: 2

The `data()` method

Where our subrange is viewing a contiguous container such as an array, the raw memory address the iterator is pointing it is available through the data() method:

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main() {
6  std::vector Nums{1, 2, 3};
7  std::ranges::subrange Subrange{Nums};
8
9  std::cout << "Pointer: " << Nums.data();
10}

1Pointer: 000001855EE84030

This is primarly used to let our subrange interact with systems that expect more basic types, such as c-style arrays:

1#include <iostream>
2#include <vector>
3#include <ranges>
4
5void Log(int Array[], std::size_t Size) {
6  for (std::size_t i{0}; i < Size; ++i) {
7    std::cout << Array[i] << ", ";
8  }
9}
10
11int main() {
12  std::vector Nums{1, 2, 3};
13  std::ranges::subrange Subrange{Nums};
14  Log(Subrange.data(), Subrange.size());
15}

11, 2, 3,

Abstract art representing computer programming

C-Style Arrays

A detailed guide to working with classic C-style arrays within C++, and why we should avoid them where possible

Summary

In this lesson, we’ve learned how std::ranges::subrange gives us a simple way to create views of some underlying container. We covered:

The std::ranges::subrange type, available within the <ranges> library.
How to create subranges from containers and use them to view data slices.
Using subrange methods like begin(), end(), size(), and empty() to manipulate views.
Applying subranges with algorithms like std::ranges::for_each and std::ranges::sort.
Understanding the concept of sized ranges and how to use size hints.
Techniques for advancing, retreating, and accessing elements within subranges.

Was this lesson useful?

Next Lesson

8 Key Standard Library Algorithms

An introduction to 8 more useful algorithms from the standard library, and how we can use them alongside views, projections, and other techniques

Ryan McCombe

Posted 2 months ago

Lesson Contents