![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/TimelineCpp20Ranges.png\")
<\/p>\nToday, I start an experiment. I want to implement beloved functions in Python in C++ using the ranges library. I’m curious about how it goes.<\/p>\n
<\/p>\n
<\/p>\n
You maybe know it. I’m also a Python trainer since 2004. Python has excellent functions, and often Python is, for me, the threshold of how comfortable a programming language could be. Today, I want to implement the Python functions range<\/span> and filter<\/span>.<\/p>\n A sequence is a term in Python that stands for something iterable such as a list<\/span> ([1, 2, 3]<\/span>), a tuple<\/span> ((1, 2, 3)<\/span>), or a string<\/span> (“123”<\/span>). Instead of a list<\/span>, I use a std::vector<\/span> in C++. The functions filter <\/span>stands for the functional style in Python.<\/p>\n Before I start with the range<\/span> function, I have to make a few remarks.<\/p>\n Let’s start with the range<\/span> function. The range<\/span> function is a kind of building block for creating integers.<\/p>\n In the following examples, I first show the Python expression commented out and then the corresponding C++ call.<\/p>\n <\/p>\n The calls in lines (1) – (4) should be quite easy to read when you look at the output.<\/p>\n The first two arguments of the range call stand for the beginning and end of the created integers. The beginning is included but not the end. Step size as the third parameter is per default 1. When the interval [begin, end[ is decreasing, the step size should be negative. If not, you get an empty list<\/span> or 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. If you know an elegant implementation based on C++20, please let me know.<\/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 I implement the eager version for filter<\/span> and map<\/span> (next post) in my examples. With Python 3 filter<\/span> and map<\/span> are lazy. filter<\/span> and map<\/span> return, in this case, generators. To get the eager behavior of Python 2, put a list<\/span> around the filter<\/span> and map<\/span> calls in Python 3.<\/p>\n <\/p>\n Both calls produce the same list: [1, 3, 5, 7, 9<\/span>].<\/p>\n I continue with the function filter<\/span> because it is easier to implement, such as the map function.<\/p>\n\n
\n
range<\/span><\/h2>\n
\n\/\/<\/span> range<\/span>.<\/span>cpp\n\n#include <iostream><\/span>\n#include <range\/v3\/all.hpp><\/span>\n#include <vector><\/span>\n\nstd::vector<<\/span>int<\/span>><\/span> range<\/span>(int<\/span> begin, int<\/span> end, int<\/span> stepsize =<\/span> 1<\/span>) {\n std::vector<<\/span>int<\/span>><\/span> result{};\n if<\/span> (begin <<\/span> end) { \/\/<\/span> (5<\/span>)\n auto boundary =<\/span> [end](int<\/span> i){ return<\/span> i <<\/span> end; };\n for<\/span> (int<\/span> i: ranges::views::iota(begin) |<\/span> ranges::views::stride(stepsize) \n |<\/span> ranges::views::take_while(boundary)) {\n result.<\/span>push_back(i);\n }\n }\n else<\/span> { \/\/<\/span> (6<\/span>)\n begin++<\/span>;\n end++<\/span>;\n stepsize *=<\/span> -<\/span>1<\/span>;\n auto boundary =<\/span> [begin](int<\/span> i){ return<\/span> i <<\/span> begin; };\n for<\/span> (int<\/span> i: ranges::views::iota(end) |<\/span> ranges::views::take_while(boundary) \n |<\/span> ranges::views::reverse \n |<\/span> ranges::views::stride(stepsize)) {\n result.<\/span>push_back(i);\n }\n }\n return<\/span> result;\n}\n \nint<\/span> main() {\n \n std::cout <<<\/span> std::endl;\n\n \/\/<\/span> range<\/span>(1<\/span>, 50<\/span>) \/\/<\/span> (1<\/span>)\n auto res =<\/span> range<\/span>(1<\/span>, 50<\/span>);\n for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\n \n std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n \n \/\/<\/span> range<\/span>(1<\/span>, 50<\/span>, 5<\/span>) \/\/<\/span> (2<\/span>)\n res =<\/span> range<\/span>(1<\/span>, 50<\/span>, 5<\/span>);\n for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\n \n std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n \n \/\/<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>1<\/span>) \/\/<\/span> (3<\/span>)\n res =<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>1<\/span>);\n for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\n \n std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n \n \/\/<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>5<\/span>) \/\/<\/span> (4<\/span>)\n res =<\/span> range<\/span>(50<\/span>, 10<\/span>, -<\/span>5<\/span>);\n for<\/span> (auto i: res) std::cout <<<\/span> i <<<\/span> \" \"<\/span>;\n \n std::cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n \n}\n<\/pre>\n<\/div>\n![\"range\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/02\/range.png\")
<\/p>\n\nfilter<\/span>(lambda<\/span> i: (i % 2) == 1 , range<\/span>(1<\/span>, 10<\/span>)) # Python 2 <\/span>\n\nlist<\/span>(filter<\/span>(lambda<\/span> i: (i % 2) == 1, range<\/span>(1<\/span>, 10<\/span>))) # Python 3<\/span>\n<\/pre>\n<\/div>\nfilter<\/span><\/h2>\n
\n\/\/<\/span> filter<\/span>.<\/span>cpp\n\n#include \"range.hpp\" \/\/ (1)<\/span>\n\n#include <fstream><\/span>\n#include <iostream><\/span>\n#include <range\/v3\/all.hpp>\n#include <sstream><\/span>\n#include <string><\/span>\n#include <vector><\/span>\n#include <utility><\/span>\n\ntemplate <<\/span>typename Func, typename Seq> \/\/ (2)<\/span><\/span>\nauto filter<\/span>(Func func, Seq seq) {\n \n typedef typename Seq::value_type value_type;\n\n std::vector<<\/span>value_type><\/span> result{};\n for<\/span> (auto i : seq |<\/span> ranges::views::filter<\/span>(func)) result.<\/span>push_back(i);\n \n return<\/span> result;\n}\n\n\nint<\/span> main() {\n \n std::cout <<<\/span> std::endl;\n \n \/\/<\/span> filter<\/span>(lambda<\/span> i: (i %<\/span> 3<\/span>) ==<\/span> 0<\/span> , range<\/span>(20<\/span>, 50<\/span>)) \/\/ (3)<\/span>\n auto res =<\/span> filter<\/span>([](int<\/span> i){ return<\/span> (i %<\/span> 3<\/span>) ==<\/span>