![\"ClassIdioms\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/01\/ClassIdioms.png\")
<\/p>\nWhen you want to use a user-defined type in a range-based for-loop, your user-defined type has to implement the Iterator Protocol.<\/p>\n
<\/p>\n
<\/p>\n
Here is the question I want to answer: What interface must a user-defined type support to be usable in a range-based for-loop.<\/p>\n
Let me start with a simple experiment and use <\/p>\n <\/p>\n C++ Insights<\/a> creates the following code out of it:<\/p>\n <\/p>\n <\/p>\n Let me write it more generally: When you use a range-based for-loop ( <\/p>\n <\/p>\n I marked the essential parts in red:<\/p>\n Let me apply the theory and create a number generator.<\/p>\n My first implementation supports the Iterator Protocol<\/p>\n The following class <\/p>\n <\/p>\n The class Finally, here is the output of the program:<\/p>\n <\/p>\n Let me generalize the iterator returned by The following improved <\/p>\n <\/p>\n std::array<\/code> in C++ Insights<\/a>. Here is a simple example:<\/p>\n\n\/\/ iteratorProtocol.cpp<\/span>\r\n\r\n#include <array><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n \r\n std::<\/span>array<<\/span>int<\/span>, 5<\/span>><\/span> myArr{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\n for<\/span> (auto<\/span> a:<\/span> myArr) a;\r\n \r\n}\r\n<\/pre>\n<\/div>\n\n#include <array><\/span>\r\n\r\nint<\/span> main<\/span>()\r\n{\r\n std::<\/span>array<<\/span>int<\/span>, 5<\/span>><\/span> myArr =<\/span> {{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>}};\r\n {\r\n std::<\/span>array<<\/span>int<\/span>, 5<\/span>><\/span> &<\/span> __range1 =<\/span> myArr;\r\n int<\/span> *<\/span> __begin1 =<\/span> __range1.begin();\r\n int<\/span> *<\/span> __end1 =<\/span> __range1.end();\r\n for<\/span>(; __begin1 !=<\/span> __end1; ++<\/span>__begin1) {\r\n int<\/span> a =<\/span> *<\/span>__begin1;\r\n a;\r\n }\r\n \r\n }\r\n return<\/span> 0<\/span>;\r\n}\r\n<\/pre>\n<\/div>\nfor(range_declaration : range_expression)<\/code>), the compiler creates the following code:<\/p>\n\n{\r\n auto && __range = range_expression ;\r\n auto __begin = begin_expr;<\/span> \r\n auto __end = end_expr;<\/span> \r\n for (;__begin !=<\/span> __end; ++<\/span>__begin) {\r\n range_declaration = *<\/span>__begin;\r\n loop_statement\r\n }\r\n}\r\n<\/pre>\n<\/div>\n\n
begin_expr <\/code>and end_expr<\/code>: return an iterator object<\/p>\n<\/li>\n\n
operator++<\/code>: incrementing the iterator<\/li>\noperator*<\/code>: dereferencing the iterator and accessing the current element<\/li>\noperator!=<\/code>: comparing the iterator with another iterator<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nbegin_expr<\/code> and end_expr<\/code> call the essential begin<\/code> and end<\/code> on the range_expression. begin and end could either be member functions or free functions on range_expression.<\/p>\nA Generator<\/h2>\n
The Iterator Protocol<\/h3>\n
Generator<\/code> supports the elementary Iterator Protocol.<\/p>\n\n\/\/ iterator.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> Generator<\/span> {\r\n int<\/span> begin_{};\r\n int<\/span> end_{};\r\n\r\npublic:<\/span>\r\n Generator(int<\/span> begin, int<\/span> end) :<\/span> begin_{begin}, end_{end} {}\r\n\r\n class<\/span> Iterator<\/span> {\r\n int<\/span> value_{};\r\n public:<\/span>\r\n explicit<\/span> Iterator(int<\/span> pos) :<\/span> value_{pos} {}\r\n\r\n int<\/span> operator<\/span>*<\/span>() const<\/span> { return<\/span> value_; } \/\/ (3)<\/span><\/em>\r\n\r\n Iterator&<\/span> operator<\/span>++<\/span>() { \/\/ (4)<\/span><\/em>\r\n ++<\/span>value_;\r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n\r\n bool<\/span> operator<\/span>!=<\/span>(const<\/span> Iterator&<\/span> other) const<\/span> { \/\/ (5)<\/span><\/em>\r\n return<\/span> value_ !=<\/span> other.value_;\r\n }\r\n };\r\n\r\n Iterator begin() const<\/span> { return<\/span> Iterator{begin_}; } \/\/ (1)<\/span><\/em>\r\n Iterator end() const<\/span> { return<\/span> Iterator{end_}; } \/\/ (2)<\/span><\/em>\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n \r\n Generator gen{100<\/span>, 110<\/span>};\r\n for<\/span> (auto<\/span> v :<\/span> gen) std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>;\r\n\r\n std::<\/span>cout <<<\/span> \"\\n\\n\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\nGenerator<\/code> has member functions begin<\/code> and end, <\/code>(lines 1 and 2) <\/code>returning iterator objects, initialized with begin_<\/code> and end_. begin_<\/code> and end_<\/code> stand for the range of created numbers. Let me analyze the inner class Iterator<\/code> which keeps track of the generated numbers: <\/code><\/p>\n\n
operator*<\/code> returns the current value<\/li>\noperator++<\/code> increments the current value<\/li>\noperator!=<\/code> compares the current value with the end_<\/code> marker.<\/li>\n<\/ul>\n![\"iterator\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/02\/iterator.png\")
<\/p>\n begin()<\/code> and end()<\/code> and make it a forward iterator. Afterward, the class Generator<\/code> can be used in most of the algorithms of the Standard Template Library. To put it differently, the unordered associative containers <\/a>support a forward iterator.<\/p>\n<\/p>\nA Forward Iterator<\/h3>\n
Generator<\/code> has an inner class Iterator that is a forward iterator.<\/p>\n\n\/\/ forwardIterator.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <numeric><\/span>\r\n\r\nclass<\/span> Generator<\/span> {\r\n int<\/span> begin_{};\r\n int<\/span> end_{};\r\n\r\n public:<\/span>\r\n Generator(int<\/span> begin, int<\/span> end) :<\/span> begin_{begin}, end_{end} {}\r\n\r\n class<\/span> Iterator<\/span> {\r\n using<\/span> iterator_category =<\/span> std::<\/span>forward_iterator_tag; \/\/ (1)<\/span><\/em>\r\n using<\/span> difference_type =<\/span> std::<\/span>ptrdiff_t<\/span>;\r\n using<\/span> value_type =<\/span> int<\/span>;\r\n using<\/span> pointer =<\/span> int<\/span>*<\/span>;\r\n using<\/span> reference =<\/span> int<\/span>&<\/span>;\r\n int<\/span> value_{};\r\n public:<\/span>\r\n explicit<\/span> Iterator(int<\/span> pos) :<\/span> value_{pos} {}\r\n\r\n value_type operator<\/span>*<\/span>() const<\/span> { return<\/span> value_; }\r\n pointer operator<\/span>-><\/span>() { return<\/span> &<\/span>value_; } \/\/ (2)<\/span><\/em> \r\n\r\n Iterator&<\/span> operator<\/span>++<\/span>() { \r\n ++<\/span>value_;\r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n Iterator operator<\/span>++<\/span>(int<\/span>) { \/\/ (3)<\/span><\/em>\r\n Iterator tmp =<\/span> *<\/span>this<\/span>; \r\n ++<\/span>(*<\/span>this<\/span>); \r\n return<\/span> tmp; \r\n }\r\n