![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/TimelineCpp20Ranges.png\")
<\/p>\nThanks to the ranges library in C++20, working with the Standard Template Library (STL) will become much more comfortable and powerful. The algorithms of the ranges library are lazy, can work directly on the container and can easily be composed. To make it short: The range library’s comfort and power are due to its functional ideas. Let me show you what that means.<\/p>\n
<\/p>\n
<\/p>\n
Before I dive into the details, here is a first example of the ranges library:<\/p>\n
<\/p>\n
\/\/ rangesFilterTransform.cpp<\/span>\n\n#include <iostream><\/span>\n#include <ranges><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n std::<\/span>vector<<\/span>int<\/span>><\/span> numbers =<\/span> {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>};\n \n auto<\/span> results =<\/span> numbers |<\/span> std::<\/span>views::<\/span>filter([](int<\/span> n){ return<\/span> n %<\/span> 2<\/span> ==<\/span> 0<\/span>; })\n |<\/span> std::<\/span>views::<\/span>transform([](int<\/span> n){ return<\/span> n *<\/span> 2<\/span>; });\n \n for<\/span> (auto<\/span> v:<\/span> results) std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>; \/\/ 4 8 12<\/span>\n\n}\n<\/pre>\n<\/div>\nYou have to read the expression from left to right.\u00a0The pipe symbol stands for function composition: First, all numbers can pass which are even (std::views::filter([](int n){ return n % 2 == 0; }<\/span>)). Afterward, each remaining number is mapped to its double (std::views::transform([](int n){ return n * 2; })<\/span>). The small example already shows two new ranges library features: Function composition, which operators on the entire container.<\/p>\nNow you should be prepared for the details. Let’s go back to square one: ranges and views are concepts.<\/p>\n
Range<\/h2>\n\n- std::range: <\/strong><\/span>A range is a group of items you can iterator over. It provides a begin iterator and an end sentinel. Of course, the containers of the STL are ranges.<\/li>\n<\/ul>\n
There exist refinements of std::range<\/span>:<\/p>\n\n- std::ranges::input_range:\u00a0s<\/span><\/span><\/strong>pecifies a range whose iterator type satisfies input_iterator (can iterate from beginning to end at least once)<\/li>\n
- std::ranges::output_range:\u00a0s<\/span><\/span><\/strong>pecifies a range whose iterator type satisfies output_iterator<\/li>\n
- std::ranges::forward_range:\u00a0s<\/span><\/span><\/span><\/strong>pecifies a range whose iterator type satisfies forward_iterator (can iterate from beginning to end more than once)<\/li>\n
- std::ranges::bidirectional_range:\u00a0s<\/span><\/span><\/span><\/strong>pecifies a range whose iterator type satisfies bidirectional_iterator (can iterate forward and backward more than once)<\/li>\n
- std::ranges::random_access_range:\u00a0s<\/span><\/span><\/span><\/strong>pecifies a range whose iterator type satisfies random_access_iterator (can jump in constant time to an arbitrary element with the index operator [])<\/li>\n
- std::ranges::contiguous_range:\u00a0s<\/span><\/span><\/span><\/strong>pecifies a range whose iterator type satisfies contiguous_iterator (elements are stored consecutively in memory)<\/li>\n<\/ul>\n
The containers of the STL and std::string<\/span> model different concepts:<\/p>\n![\"RangeConcepts\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/RangeConcepts.png\")
<\/p>\n
A container supporting the std::ranges::contiguous_range <\/span>concept supports all other concepts above, such as std::ranges::random_access_range<\/span>, std::ranges::bidirectional_range<\/span>, and std::ranges::input_range<\/span>. The same observation holds for all other ranges.<\/p>\nView<\/span><\/p>\n\n- You apply a View on a range and perform some operations. A view does not own data, and it’s time to copy, move, assignment its constant. Here is a quote from Eric Niebler’s range-v3 implementation<\/a>, which is the base for the C++20 ranges: “Views are composable adaptations of ranges where the adaptation happens lazily as the view is iterated.<\/em>“<\/li>\n<\/ul>\n
<\/p>\n
\nstd::<\/span>vector<<\/span>int<\/span>><\/span> numbers =<\/span> {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>};\n\nauto<\/span> results =<\/span> numbers |<\/span> std::<\/span>views::<\/span>filter([](int<\/span> n){ return<\/span> n %<\/span> 2<\/span> ==<\/span> 0<\/span>; })\n |<\/span> std::<\/span>views::<\/span>transform([](int<\/span> n){ return<\/span> n *<\/span> 2<\/span>; });\n<\/pre>\n<\/div>\nIn this code snippet, numbers<\/span> are the range, and std::views::filter<\/span> and std::views::transform<\/span> are the views.<\/p>\nDue to the power of views, C++20 allows programming in a functional style. Views can be combined and are lazy. <\/strong>l already presented two views, but we get more.<\/p>\n<\/p>\n
\nstd::<\/span>all_view, std::<\/span>views::<\/span>all \/\/ takes all elements<\/span>\n\nstd::<\/span>ref_view \/\/ takes all elements of another view<\/span>\n\nstd::<\/span>filter_view, std::<\/span>views::<\/span>filter \/\/ takes the elements which satisfies the predicate<\/span>\n\nstd::<\/span>transform_view, std::<\/span>views::<\/span>transform \/\/ transforms each element<\/span>\n\nstd::<\/span>take_view, std::<\/span>views::<\/span>take \/\/ takes the first N elements of another view<\/span>\n\nstd::<\/span>take_while_view, std::<\/span>views::<\/span>take_while \/\/ takes the elements of another view as long as the predicate returns true<\/span>\n\nstd::<\/span>drop_view, std::<\/span>views::<\/span>drop \/\/ skips the first N elements of another view<\/span>\n\nstd::<\/span>drop_while_view, std::<\/span>views::<\/span>drop_while \/\/ skips the initial elements of another view until the predicate returns false<\/span>\n\nstd::<\/span>join_view, std::<\/span>views::<\/span>join \/\/ joins a view of ranges<\/span>\n\nstd::<\/span>split_view, std::<\/span>views::<\/span>split \/\/ splits a view by using a delimiter<\/span>\n\nstd::<\/span>common_view, std::<\/span>views::<\/span>common \/\/ converts a view into a std::common_range<\/span>\n\nstd::<\/span>reverse_view, std::<\/span>views::<\/span>reverse \/\/ iterates in reverse order<\/span>\n\nstd::<\/span>basic_istream_view, std::<\/span>istream_view \/\/ applies operator>> on the view<\/span>\n\nstd::<\/span>elements_view, std::<\/span>views::<\/span>elements \/\/ creates a view on the N-th element of tuples<\/span>\n\nstd::<\/span>keys_view, std::<\/span>views::<\/span>keys \/\/ creates a view on the first element of a pair-like values<\/span>\n\nstd::<\/span>values_view, std::<\/span>views::<\/span>values \/\/ creates a view on the second elements of a pair-like values<\/span>\n<\/pre>\n<\/div>\nYou can generally use a view such as std::views::transform<\/span> with the alternative name std::transform_view<\/span>.\u00a0 I show the usage of various views as I go on.<\/p>\nImplementation Status<\/h2>\n
As far as I know, there is no implementation of the ranges library now (February 2020) available. This is not an issue. You can use the mentioned\u00a0 range-v3 implementation on the online Wandbox<\/a> or the Compiler Explorer <\/a>with the HEAD GCC. Here is what you have to do to translate my examples, such as\u00a0rangesFilterTransform.cpp<\/span> to see it in action.<\/span><\/p>\n\n- Replace the namespaces std::views::<\/span> with ranges::views::.<\/span><\/li>\n
- Replace the header <ranges><\/span> with the header <range\/v3\/all.hpp><\/span>. For more details, study the documentation in\u00a0range-v3 implementation<\/a>.<\/li>\n
- Compile your program with C++20 support:\u00a0
-std=c++2a.<\/code><\/li>\n- When you use Compiler Explorer<\/a>, you have to use the trunk version of the\u00a0range-v3 implementation<\/a>. The following picture should help you find the option.<\/li>\n<\/ul>\n
![\"CompilerExplorer\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/CompilerExplorer.png\")
<\/p>\n
Transforming the program get\u00a0rangesFilterTransform.cpp<\/span> gives me the following program.<\/p>\n<\/p>\n
\n\/\/ rangesV3FilterTransform.cpp<\/span>\n\n#include <iostream><\/span>\n#include <range\/v3\/all.hpp><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n std::<\/span>vector<<\/span>int<\/span>><\/span> numbers =<\/span> {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>};\n \n auto<\/span> results =<\/span> numbers |<\/span> ranges::<\/span>views::<\/span>filter([](int<\/span> n){ return<\/span> n %<\/span> 2<\/span> ==<\/span> 0<\/span>; })\n |<\/span> ranges::<\/span>views::<\/span>transform([](int<\/span> n){ return<\/span> n *<\/span>