{"id":6384,"date":"2022-06-16T20:10:47","date_gmt":"2022-06-16T20:10:47","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/ranges-improvements-with-c-23\/"},"modified":"2023-06-26T09:03:48","modified_gmt":"2023-06-26T09:03:48","slug":"ranges-improvements-with-c-23","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/ranges-improvements-with-c-23\/","title":{"rendered":"Ranges Improvements with C++23"},"content":{"rendered":"

Thanks to C++23, constructing containers will become more convenient. Additionally, the ranges library got more new views.<\/p>\n

<\/p>\n

 <\/p>\n

\"Cpp23\"<\/p>\n

Ranges<\/h2>\n

C++23 is not such a significant standard as C++11 or C++20. It’s more in the tradition of C++17. This is mainly due to COVID-19 because the annual four face-to-face meetings went online. Essentially, the ranges library is the exception to this rule. The ranges will get a few crucial additions.<\/p>\n

If you know more details about what you can expect about C++23 (before I write about it), study cppreference.com\/compiler_support<\/a>. Even better, read the excellent paper from Steve Downey (C++23 Status Report<\/a>).<\/p>\n<\/p>\n

Constructing Containers<\/h3>\n

Constructing a container from a range was a complicated job. The following function range simulates python2’s range function. Python2’s range function is eager, and so is its range pendant: Additionally, Pythons range function returns a list<\/code>, but mine a std::vector<\/code>.<\/p>\n

 <\/p>\n

<\/p>\n

\n
\/\/<\/span> range<\/span>.<\/span>cpp\r\n\r\n#include <iostream><\/span>\r\n#include <range\/v3\/all.hpp><\/span>\r\n#include <vector><\/span>\r\n\r\nstd::vector<<\/span>int<\/span>><\/span> range<\/span>(int<\/span> begin, int<\/span> end, int<\/span> stepsize =<\/span> 1<\/span>) {\r\n    std::vector<<\/span>int<\/span>><\/span> result{};\r\n    if<\/span> (begin <<\/span> end) {                                     \/\/<\/span> (5<\/span>)\r\n        auto boundary =<\/span> [end](int<\/span> i){ return<\/span> i <<\/span> end; };\r\n        for<\/span> (int<\/span> i: ranges::views::iota(begin) |<\/span> ranges::views::stride(stepsize) \r\n                                               |<\/span> ranges::views::take_while(boundary)) {\r\n            result.<\/span>push_back(i);\r\n        }\r\n    }\r\n    else<\/span> {                                                 \/\/<\/span> (6<\/span>)\r\n        begin++<\/span>;\r\n        end++<\/span>;\r\n        stepsize *=<\/span> -<\/span>1<\/span>;\r\n        auto boundary =<\/span> [begin](int<\/span> i){ return<\/span> i <<\/span> begin; };\r\n        for<\/span> (int<\/span> i: ranges::views::iota(end) |<\/span> ranges::views::take_while(boundary) \r\n                                             |<\/span> ranges::views::reverse \r\n                                             |<\/span> ranges::views::stride(stepsize)) {\r\n            result.<\/span>push_back(i);\r\n        }\r\n    }\r\n    return<\/span> result;\r\n}<\/span><\/span><\/span><\/span><\/span><\/span><\/span>\r\n        \r\nint<\/span> main() {\r\n    \r\n    std::cout <<<\/span> std::endl;\r\n\r\n    \/\/<\/span> range<\/span>(1<\/span>, 50<\/span>)                                       \/\/<\/span> (1<\/span>)\r\n    auto res =<\/span> range<\/span>(1<\/span>, 50<\/span>);\r\n    for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\r\n    \r\n    std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n    \/\/<\/span> range<\/span>(1<\/span>, 50<\/span>, 5<\/span>)                                    \/\/<\/span> (2<\/span>)\r\n    res =<\/span> range<\/span>(1<\/span>, 50<\/span>, 5<\/span>);\r\n    for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\r\n    \r\n    std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n    \/\/<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>1<\/span>)                                  \/\/<\/span> (3<\/span>)\r\n    res =<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>1<\/span>);\r\n    for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\r\n    \r\n    std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n    \/\/<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>5<\/span>)                                  \/\/<\/span> (4<\/span>)\r\n    res =<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>5<\/span>);\r\n    for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\r\n    \r\n    std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The calls in lines (1) – (4) should be pretty easy to read when looking at the output.<\/p>\n
\"range\"<\/p>\n
The first two arguments of the range call stand for the beginning and end of the created integers. The begin is included but not the end. The step size as the third parameter is, per default, 1. The step size should be negative when the interval [begin, end] decreases. If not, you get an empty list<\/span> or an empty std::vector<int><\/span>.<\/p>\n
I cheat a little in my range implementation. I use the function ranges::views::stride<\/span>, which is not part of C++20. stride(n)<\/span> returns the n-th element of the given range. I assume that std::views::stride<\/code> becomes part of C++23, but I’m not sure. Consequentially, I used the ranges v3<\/a> implementation in my example but not the C++20 implementation of the ranges library.<\/p>\n
The if condition (begin < end<\/span>) of the range function in line (1) should be quite easy to read. Create all numbers starting with begin (ranges::views::iota(begin)),<\/span> take each n-th element (ranges::views::stride(stepsize<\/span>), and do it as long as the boundary condition holds (ranges::views::take_while(boundar<\/span>y). Finally, push the integers on the std::vector<int>. <\/span><\/p>\n
I use a little trick in the other case (line 2). I create the numbers [end++, begin++[,<\/span> take them until the boundary condition is met, reverse them (ranges::views::reverse<\/span>), and take each n-th element.<\/p>\n
Now, let’s assume that std::views::stride is part of C++23. Thanks to std::ranges::to, it’s pretty easy to construct a Container. Here is the C++23-based implementation of the previous range<\/code> function.<\/p>\n
 <\/p>\n
<\/p>\n
\n
std::<\/span>vector<<\/span>int<\/span>><\/span> range(int<\/span> begin, int<\/span> end, int<\/span> stepsize =<\/span> 1<\/span>) {\r\n    std::<\/span>vector<<\/span>int<\/span>><\/span> result{};\r\n    if<\/span> (begin <<\/span> end) {                                    \r\n        auto<\/span> boundary =<\/span> [end](int<\/span> i){ return<\/span> i <<\/span> end; };\r\n        result =<\/span> std::<\/span>ranges::<\/span>views::<\/span>iota(begin) |<\/span> std::<\/span>views::<\/span>stride(stepsize) \r\n                                                 |<\/span> std::<\/span>views::<\/span>take_while(boundary) \r\n                                                 |<\/span> std::<\/span>ranges::<\/span>to<std::<\/span>vector><\/span>();\r\n    }\r\n    else<\/span> {                                                \r\n        begin++<\/span>;\r\n        end++<\/span>;\r\n        stepsize *=<\/span> -<\/span>1<\/span>;\r\n        auto<\/span> boundary =<\/span> [begin](int<\/span> i){ return<\/span> i <<\/span> begin; };\r\n        result =<\/span> std::<\/span>ranges::<\/span>views::<\/span>iota(end) |<\/span> std::<\/span>views::<\/span>take_while(boundary) \r\n                                               |<\/span> std::<\/span>views::<\/span>reverse \r\n                                               |<\/span> std::<\/span>views::<\/span>stride(stepsize) \r\n                                               |<\/span> std::<\/span>ranges::<\/span>to<std::<\/span>vector><\/span>();\r\n    }\r\n    return<\/span> result;\r\n} \r\n<\/pre>\n<\/div>\n
 <\/p>\n
Essentially, I replaced the push_back<\/code> operation on the std::vector<\/code> with the new call std::ranges::to<std::vector>, <\/code>and got rid of two lines of code. So far, no compiler supports this new convenient function to create a container. I created the new range<\/code> function based on my interpretation of the specification. If there is an error included, I will fix it.<\/p>\n
Existing Algorithms in C++20<\/h4>\n
Before I show you the new views in C++23, here are the already existing ones in C++20:<\/p>\n
 \"viewNew\"<\/p>\n
New Views in C++23<\/h4>\n
Now, I want to present to you the new views. If possible, I will provide you with a short code example.<\/p>\n