{"id":6361,"date":"2022-05-19T11:53:53","date_gmt":"2022-05-19T11:53:53","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/the-ranges-library-in-c-20-a-deep-dive\/"},"modified":"2023-09-27T16:58:12","modified_gmt":"2023-09-27T16:58:12","slug":"the-ranges-library-in-c-20-a-deep-dive","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/the-ranges-library-in-c-20-a-deep-dive\/","title":{"rendered":"The Ranges Library in C++20: More Details"},"content":{"rendered":"

Working with the Standard Template Library (STL) is much more comfortable and powerful thanks to the ranges library. The algorithms of the ranges library are lazy, can work directly on the container, and can quickly be composed. But there is more to it:<\/p>\n

<\/p>\n

\"\"<\/p>\n

Before I dive deep into the ranges library in C++20, I want to recap in a few sentences the three main features of the ranges: The algorithms of the ranges can directly operate on the container, evaluate their arguments lazily, and can be composed.<\/p>\n

Direct on the Container<\/h2>\n

The classical algorithms of the Standard Template Library (STL) are sometimes a little inconvenient. They need a beginning and an end iterator. This is often more than you want to write.<\/p>\n

<\/p>\n

\n
\/\/ sortClassical.cpp<\/span>\n\n#include <algorithm><\/span>\n#include <iostream><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>()  {\n\n    std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{-<\/span>3<\/span>, 5<\/span>, 0<\/span>, 7<\/span>, -<\/span>4<\/span>};\n    std::<\/span>sort(myVec.begin(), myVec.end());     \/\/ (1)<\/span><\/em>\n    for<\/span> (auto<\/span> v:<\/span> myVec) std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>; \/\/ -4, -3, 0, 5, 7<\/span>\n\n}\n<\/pre>\n<\/div>\n
\n
Wouldn’t it be nice if\u00a0std::sort<\/code> (line 1) could be executed on the entire container? Thanks to the ranges library, this is possible in C++20.<\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ sortRanges.cpp<\/span>\n\n#include <algorithm><\/span>\n#include <iostream><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>()  {\n\n    std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{-<\/span>3<\/span>, 5<\/span>, 0<\/span>, 7<\/span>, -<\/span>4<\/span>};\n    std::<\/span>ranges::<\/span>sort(myVec);                  \/\/ (1)<\/span><\/em>\n    for<\/span> (auto<\/span> v:<\/span> myVec) std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>; \/\/ -4, -3, 0, 5, 7<\/span>\n\n}\n<\/pre>\n<\/div>\n
std::ranges::sort<\/code> (line 1) operates directly on the container.<\/p>\n
Lazy Evaluation<\/h2>\n
\n
std::views::iota<\/a><\/code> is a range factory for creating a sequence of elements by successively incrementing an initial value. This sequence can be finite or infinite. The elements of the range factory are only created when needed.<\/div>\n
<\/div>\n
<\/p>\n
\n
\/\/ lazyRanges.cpp<\/span>\n\n#include <iostream><\/span>\n#include <ranges><\/span>\n\nint<\/span> main<\/span>() {\n                                    \n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>\"<\/span>;\n\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1<\/span>'<\/span>000<\/span>'<\/span>000<\/span>, 1<\/span>'<\/span>000<\/span>'<\/span>010<\/span>)) {     \/\/ (1)<\/span>\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n                                         \n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1<\/span>'<\/span>000<\/span>'<\/span>000<\/span>)                   \/\/ (2)<\/span>\n                |<\/span> std::<\/span>views::<\/span>take(10<\/span>)) {\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1<\/span>'<\/span>000<\/span>'<\/span>000<\/span>)                  \/\/ (3)<\/span>\n                |<\/span> std::<\/span>views::<\/span>take_while([](auto<\/span> i) { return<\/span> i <<\/span> 1<\/span>'<\/span>000<\/span>'<\/span>010<\/span>; } )) {\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n\n}\n<\/pre>\n<\/div>\n<\/div>\n
The small program shows the difference between creating a finite data stream (line 1) and an infinite data stream (lines 2 and 3). When you create an infinite data stream, you need a boundary condition. Line (2) uses the view std::views::take(10)<\/code>, and line 3, the view std::views::take_while<\/code>. std::views::take_while<\/code> requires a predicate. This is an ideal fit for a lambda expression:\u00a0 [](auto i) { return i < 1'000'010; }. <\/code>Since C++14, you can use single quotes as separators in integer literals: 1'000'010.<\/code> All three std::views::ranges<\/code> calls produce the same numbers.<\/p>\n
\"lazyRanges\"<\/h2>\n
I already used the pipe operator (|<\/code>) in this example for function composition. Let’s go one step further.<\/p>\n
Function Composition<\/h2>\n
The following program primesLazy.cpp<\/code> creates the first ten prime numbers starting with one million.<\/p>\n
<\/p>\n
\n
\/\/ primesLazy.cpp<\/span>\n\n#include <iostream><\/span>\n#include <ranges><\/span>\n\n\nbool<\/span> isPrime<\/span>(int<\/span> i) {\n    for<\/span> (int<\/span> j=<\/span>2<\/span>; j*<\/span>j <=<\/span> i; ++<\/span>j){\n        if<\/span> (i %<\/span> j ==<\/span> 0<\/span>) return<\/span> false<\/span>;\n    }\n    return<\/span> true<\/span>;\n}\n\nint<\/span> main<\/span>() {\n                                        \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n                                         \n    auto<\/span> odd =<\/span> [](int<\/span> i){ return<\/span> i %<\/span> 2<\/span> ==<\/span> 1<\/span>; };\n\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1<\/span>'<\/span>000<\/span>'<\/span>000<\/span>) |<\/span> std::<\/span>views::<\/span>filter(odd) \n                                            |<\/span> std::<\/span>views::<\/span>filter(isPrime) \n                                            |<\/span> std::<\/span>views::<\/span>take(10<\/span>)) {\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\n
You have to read the function composition from left to right: I create an infinite data stream starting with 1’000’000 (std::views::iota(1'000'000)<\/code>) and apply two filters. Each filter needs a predicate. The first filter lets the odd element pass (std::<\/span>views::<\/span>filter(odd)<\/code>), and the second filter lets the prime numbers pass (std::<\/span>views::<\/span>filter(isPrime)<\/code>). To end the infinite data stream, I stop after ten numbers (std::views::take(10)<\/code>).\u00a0 Finally, here are the first ten prime numbers starting with one million.<\/div>\n
\"primesLazy\"<\/p>\n
You may ask: Who starts the processing of this data pipeline? Now, it goes from right to left. The data sink (std::views::take(10)<\/code>) want to have the next value and ask its predecessor. This request goes on until the range-based for-loop as the data source can produce one number.<\/p>\n
This was my short recap. When you want to read more about the ranges library, read my previous posts:<\/p>\n