![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/TimelineCpp20Ranges.png\")
<\/p>\nThere are more reasons to prefer ranges library above the classical Standard Template Library. The ranges iterators support unified lookup rules and provide additional safety guarantees.<\/p>\n
<\/p>\n
<\/p>\n
Assume you want to implement a generic function that calls <\/p>\n I can solve this issue by providing two different <\/p>\n The classical way to solve this issue is to bring Finally, let me write about safety.<\/p>\n Let me start with iterators.<\/p>\n There is a big difference when you use these operations for accessing the underlying range. The compilation fails when you use the range access on the <\/p>\n The abbreviations lvalue and rvalue stand for locatable value and readable value.<\/p>\nbegin<\/code> on a given container. The question is if the function calling begin<\/code> on a container should assume a free begin<\/code> function or a member function begin<\/code>?<\/p>\n\n\/\/ begin.cpp<\/span>\n\n#include <cstddef><\/span>\n#include <iostream><\/span>\n#include <ranges><\/span>\n\nstruct<\/span> ContainerFree { \/\/ (1)<\/span>\n ContainerFree(std::<\/span>size_t<\/span> len):<\/span> len_(len), data_(new<\/span> int<\/span>[len]){}\n size_t<\/span> len_;\n int<\/span>*<\/span> data_;\n};\nint<\/span>*<\/span> begin<\/span>(const<\/span> ContainerFree&<\/span> conFree) { \/\/ (2)<\/span>\n return<\/span> conFree.data_;\n}\n\nstruct<\/span> ContainerMember { \/\/ (3)<\/span>\n ContainerMember(std::<\/span>size_t<\/span> len):<\/span> len_(len), data_(new<\/span> int<\/span>[len]){}\n int<\/span>*<\/span> begin() const<\/span> { \/\/ (4)<\/span>\n return<\/span> data_;\n }\n size_t<\/span> len_;\n int<\/span>*<\/span> data_;\n};\n\nvoid<\/span> callBeginFree<\/span>(const<\/span> auto<\/span>&<\/span> cont) { \/\/ (5)<\/span>\n begin(cont);\n}\n\nvoid<\/span> callBeginMember<\/span>(const<\/span> auto<\/span>&<\/span> cont) { \/\/ (6)<\/span>\n cont.begin();\n}\n \nint<\/span> main<\/span>() {\n\n const<\/span> ContainerFree contFree(2020<\/span>);\n const<\/span> ContainerMember contMemb(2023<\/span>);\n\n callBeginFree(contFree); \n callBeginMember(contMemb);\n\n callBeginFree(contMemb); \/\/ (7)<\/span>\n callBeginMember(contFree); \/\/ (8)<\/span>\n \n}\n<\/pre>\n<\/div>\n\nContainerFree<\/code> (line 1) has a free function begin<\/code> (line 2), and ContainerMember<\/code> (line 3) has a member function begin<\/code> (line 4). Accordingly, contFree<\/code> can use the generic function callBeginFree<\/code> using the free function call begin(cont)<\/code> (line 5), and contMemb<\/code> can use the generic function callBeginMember<\/code> using the member function call cont.begin<\/code> (line 6). When I invoke callBeginFree<\/code> and callBeginMember<\/code> The compilation fails with the inappropriate containers in lines (7) and (8).<\/div>\n![\"begin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/begin.png\")
<\/div>\n<\/div>\nbegin<\/code> implementations: classical and range based.<\/p>\n\n\/\/ beginSolved.cpp<\/span>\n\n#include <cstddef><\/span>\n#include <iostream><\/span>\n#include <ranges><\/span>\n\nstruct<\/span> ContainerFree {\n ContainerFree(std::<\/span>size_t<\/span> len):<\/span> len_(len), data_(new<\/span> int<\/span>[len]){}\n size_t<\/span> len_;\n int<\/span>*<\/span> data_;\n};\nint<\/span>*<\/span> begin<\/span>(const<\/span> ContainerFree&<\/span> conFree) {\n return<\/span> conFree.data_;\n}\n\nstruct<\/span> ContainerMember {\n ContainerMember(std::<\/span>size_t<\/span> len):<\/span> len_(len), data_(new<\/span> int<\/span>[len]){}\n int<\/span>*<\/span> begin() const<\/span> {\n return<\/span> data_;\n }\n size_t<\/span> len_;\n int<\/span>*<\/span> data_;\n};\n\nvoid<\/span> callBeginClassical<\/span>(const<\/span> auto<\/span>&<\/span> cont) {\n using<\/span> std::<\/span>begin; \/\/ (1)<\/span>\n begin(cont);\n}\n\nvoid<\/span> callBeginRanges<\/span>(const<\/span> auto<\/span>&<\/span> cont) {\n std::<\/span>ranges::<\/span>begin(cont); \/\/ (2)<\/span>\n}\n \nint<\/span> main<\/span>() {\n\n const<\/span> ContainerFree contFree(2020<\/span>);\n const<\/span> ContainerMember contMemb(2023<\/span>);\n\n callBeginClassical(contFree);\n callBeginRanges(contMemb);\n\n callBeginClassical(contMemb);\n callBeginRanges(contFree);\n \n}\n<\/pre>\n<\/div>\n std::begin<\/code> into the scope with a so-called using-declaration (line 1). Thanks to ranges, you can directly use std::ranges::begin<\/code> (line 2). std::ranges::begin<\/code> considers both implementations of begin<\/code>: the free version and the member function.<\/p>\nSafety<\/h2>\n
Iterators<\/h3>\n
\nThe ranges library provides the expected operations to access the range.<\/div>\n<\/div>\n\u00a0![\"iterators\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/iterators.jpg\")
<\/div>\n<\/div>\nstd::ranges<\/code>‘s variant if the argument is an rvalue. On the contrary, using the same operation from the classical std<\/code> namespace is undefined behavior.<\/p>\n\n\/\/ rangesAccess.cpp<\/span>\n\n#include <iterator><\/span>\n#include <ranges><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n auto<\/span> beginIt1 =<\/span> std::<\/span>begin(std::<\/span>vector<<\/span>int<\/span>><\/span>{1<\/span>, 2<\/span>, 3<\/span>});\n auto<\/span> beginIt2 =<\/span> std::<\/span>ranges::<\/span>begin(std::<\/span>vector<<\/span>int<\/span>><\/span>{1<\/span>, 2<\/span>, 3<\/span>});\n\n}\n<\/pre>\n<\/div>\nstd::ranges::begin<\/code> provides only overloads for lvalues. The temporary vector std::vector{1, 2, 3}<\/code> is an rvalue. Consequentially, the compilation of the program fails.<\/p>\n![\"rangeAccessError\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/rangeAccessError.png\")
<\/p>\n\n
![\"temporaryRange\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/temporaryRange.png\")
<\/p>\n