{"id":1965,"date":"2024-06-22T09:53:00","date_gmt":"2024-06-22T09:53:00","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1965"},"modified":"2024-06-22T09:53:05","modified_gmt":"2024-06-22T09:53:05","slug":"how-to-implement-custom-iterators-in-cpp","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/","title":{"rendered":"How to Implement Custom Iterators in C++"},"content":{"rendered":"\n

Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection, such as arrays, vectors, lists, and more. Custom iterators are essential when you create your own data structures and want them to work seamlessly with the standard algorithms provided by the STL. In this tutorial, we’ll explore how to implement custom iterators in C++.<\/p>\n\n\n\n

1. Introduction to Iterators<\/h2>\n\n\n\n

Iterators are objects that allow a programmer to traverse through elements of a collection. They are designed to provide a way to access elements without exposing the underlying representation of the collection.<\/p>\n\n\n\n

STL Iterator Example<\/h3>\n\n\n
#include<\/span> <vector><\/span><\/span>\n#include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n    for<\/span> (auto<\/span> it = vec.begin(); it != vec.end(); ++it) {\n        std<\/span>::cout<\/span> << *it << \" \"<\/span>;\n    }\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
In the above code, vec.begin()<\/code> returns an iterator to the beginning of the vector, and vec.end()<\/code> returns an iterator to one past the last element. The iterator is used to traverse and print each element.<\/p>\n\n\n\n
2. Types of Iterators<\/h2>\n\n\n\n
The STL defines several types of iterators based on their capabilities:<\/p>\n\n\n\n
    \n
  • Input Iterator<\/strong>: Read-only access, single pass.<\/li>\n\n\n\n
  • Output Iterator<\/strong>: Write-only access, single pass.<\/li>\n\n\n\n
  • Forward Iterator<\/strong>: Read and write access, multiple passes, can move only forward.<\/li>\n\n\n\n
  • Bidirectional Iterator<\/strong>: Read and write access, multiple passes, can move both forward and backward.<\/li>\n\n\n\n
  • Random Access Iterator<\/strong>: Read and write access, multiple passes, can move freely (supports arithmetic operations like +<\/code>, -<\/code>).<\/li>\n<\/ul>\n\n\n\n
    3. Requirements for Custom Iterators<\/h2>\n\n\n\n
    To create a custom iterator, you need to follow certain conventions and implement specific functions. These conventions ensure that your iterator will be compatible with STL algorithms and containers.<\/p>\n\n\n\n
    Iterator Traits<\/h3>\n\n\n\n
    Iterator traits are used to provide information about the iterator. They define types such as value_type<\/code>, difference_type<\/code>, pointer<\/code>, reference<\/code>, and iterator_category<\/code>.<\/p>\n\n\n\n
    Basic Operations<\/h3>\n\n\n\n
    A custom iterator must support the following operations:<\/p>\n\n\n\n
      \n
    • Dereferencing<\/strong>: Access the value pointed to by the iterator using the *<\/code> operator.<\/li>\n\n\n\n
    • Increment<\/strong>: Move to the next element using the ++<\/code> operator.<\/li>\n\n\n\n
    • Equality\/Inequality<\/strong>: Compare iterators using ==<\/code> and !=<\/code> operators.<\/li>\n<\/ul>\n\n\n\n
      4. Implementing a Custom Iterator<\/h2>\n\n\n\n
      Let’s start with a basic custom iterator for a simple container.<\/p>\n\n\n\n
      Iterator Traits<\/h3>\n\n\n\n
      Define the necessary traits for the iterator.<\/p>\n\n\n
      #include<\/span> <iterator><\/span><\/span>\n\ntemplate<\/span> <typename<\/span> T>\nclass<\/span> SimpleIterator<\/span> {<\/span>\npublic<\/span>:\n    using<\/span> value_type = T;\n    using<\/span> difference_type = std<\/span>::ptrdiff_t<\/span>;\n    using<\/span> pointer = T*;\n    using<\/span> reference = T&;\n    using<\/span> iterator_category = std<\/span>::forward_iterator_tag;\n\n    SimpleIterator(pointer ptr) : m_ptr(ptr) {}\n\n    reference operator<\/span>*() const<\/span> { return<\/span> *m_ptr; }\n    pointer operator<\/span>->() { return<\/span> m_ptr; }\n\n    \/\/ Prefix increment<\/span>\n    SimpleIterator& operator<\/span>++() {\n        m_ptr++;\n        return<\/span> *this<\/span>;\n    }\n\n    \/\/ Postfix increment<\/span>\n    SimpleIterator operator<\/span>++(int<\/span>) {\n        SimpleIterator tmp = *this<\/span>;\n        ++(*this<\/span>);\n        return<\/span> tmp;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>==(const<\/span> SimpleIterator& a, const<\/span> SimpleIterator& b) {\n        return<\/span> a.m_ptr == b.m_ptr;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>!=(const<\/span> SimpleIterator& a, const<\/span> SimpleIterator& b) {\n        return<\/span> a.m_ptr != b.m_ptr;\n    }\n\nprivate<\/span>:\n    pointer m_ptr;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      Basic Structure<\/h3>\n\n\n\n
      Now, let’s create a simple container that uses this iterator.<\/p>\n\n\n
      template<\/span> <typename<\/span> T>\nclass<\/span> SimpleContainer<\/span> {<\/span>\npublic<\/span>:\n    using<\/span> iterator = SimpleIterator<T>;\n\n    SimpleContainer(std<\/span>::initializer_list<\/span><T> init) {\n        size = init.size();\n        data = new<\/span> T[size];\n        std<\/span>::copy(init.begin(), init.end(), data);\n    }\n\n    ~SimpleContainer() {\n        delete<\/span>[] data;\n    }\n\n    iterator begin<\/span>()<\/span> <\/span>{ return<\/span> iterator(data); }\n    iterator end<\/span>()<\/span> <\/span>{ return<\/span> iterator(data + size); }\n\nprivate<\/span>:\n    T* data;\n    size_t<\/span> size;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      Iterator Operations<\/h3>\n\n\n\n
      In the SimpleIterator<\/code> class, we have defined basic iterator operations such as dereferencing, incrementing, and comparison. The SimpleContainer<\/code> class uses this iterator.<\/p>\n\n\n\n
      5. Example: Custom Iterator for a Simple Container<\/h2>\n\n\n\n
      Let’s put it all together with a complete example.<\/p>\n\n\n
      #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    SimpleContainer<int<\/span>> container = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n\n    for<\/span> (auto<\/span> it = container.begin(); it != container.end(); ++it) {\n        std<\/span>::cout<\/span> << *it << \" \"<\/span>;\n    }\n    std<\/span>::cout<\/span> << std<\/span>::endl<\/span>;\n\n    std<\/span>::for_each(container.begin(), container.end(), [](int<\/span> &n) { n *= 2<\/span>; });\n\n    for<\/span> (auto<\/span> it = container.begin(); it != container.end(); ++it) {\n        std<\/span>::cout<\/span> << *it << \" \"<\/span>;\n    }\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      This example demonstrates how to create and use a custom iterator with a simple container.<\/p>\n\n\n\n
      6. Advanced Features<\/h2>\n\n\n\n
      Input and Output Iterators<\/h3>\n\n\n\n
      Input and output iterators have specific requirements. Let’s implement an input iterator.<\/p>\n\n\n
      template<\/span> <typename<\/span> T>\nclass<\/span> InputIterator<\/span> {<\/span>\npublic<\/span>:\n    using<\/span> value_type = T;\n    using<\/span> difference_type = std<\/span>::ptrdiff_t<\/span>;\n    using<\/span> pointer = T*;\n    using<\/span> reference = T&;\n    using<\/span> iterator_category = std<\/span>::input_iterator_tag;\n\n    InputIterator(pointer ptr) : m_ptr(ptr) {}\n\n    reference operator<\/span>*() const<\/span> { return<\/span> *m_ptr; }\n    pointer operator<\/span>->() { return<\/span> m_ptr; }\n\n    InputIterator& operator<\/span>++() {\n        m_ptr++;\n        return<\/span> *this<\/span>;\n    }\n\n    InputIterator operator<\/span>++(int<\/span>) {\n        InputIterator tmp = *this<\/span>;\n        ++(*this<\/span>);\n        return<\/span> tmp;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>==(const<\/span> InputIterator& a, const<\/span> InputIterator& b) {\n        return<\/span> a.m_ptr == b.m_ptr;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>!=(const<\/span> InputIterator& a, const<\/span> InputIterator& b) {\n        return<\/span> a.m_ptr != b.m_ptr;\n    }\n\nprivate<\/span>:\n    pointer m_ptr;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      Forward, Bidirectional, and Random Access Iterators<\/h3>\n\n\n\n
      Bidirectional and random access iterators build on top of forward iterators by adding more functionality.<\/p>\n\n\n\n
      Bidirectional Iterator<\/h4>\n\n\n
      template<\/span> <typename<\/span> T>\nclass<\/span> BidirectionalIterator<\/span> {<\/span>\npublic<\/span>:\n    using<\/span> value_type = T;\n    using<\/span> difference_type = std<\/span>::ptrdiff_t<\/span>;\n    using<\/span> pointer = T*;\n    using<\/span> reference = T&;\n    using<\/span> iterator_category = std<\/span>::bidirectional_iterator_tag;\n\n    BidirectionalIterator(pointer ptr) : m_ptr(ptr) {}\n\n    reference operator<\/span>*() const<\/span> { return<\/span> *m_ptr; }\n    pointer operator<\/span>->() { return<\/span> m_ptr; }\n\n    BidirectionalIterator& operator<\/span>++() {\n        m_ptr++;\n        return<\/span> *this<\/span>;\n    }\n\n    BidirectionalIterator operator<\/span>++(int<\/span>) {\n        BidirectionalIterator tmp = *this<\/span>;\n        ++(*this<\/span>);\n        return<\/span> tmp;\n    }\n\n    BidirectionalIterator& operator<\/span>--() {\n        m_ptr--;\n        return<\/span> *this<\/span>;\n    }\n\n    BidirectionalIterator operator<\/span>--(int<\/span>) {\n        BidirectionalIterator tmp = *this<\/span>;\n        --(*this<\/span>);\n        return<\/span> tmp;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>==(const<\/span> BidirectionalIterator& a, const<\/span> BidirectionalIterator& b) {\n        return<\/span> a.m_ptr == b.m_ptr;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>!=(const<\/span> BidirectionalIterator& a, const<\/span> BidirectionalIterator& b) {\n        return<\/span> a.m_ptr != b.m_ptr;\n    }\n\nprivate<\/span>:\n    pointer m_ptr;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      Random Access Iterator<\/h4>\n\n\n
      template<\/span> <typename<\/span> T>\nclass<\/span> RandomAccessIterator<\/span> {<\/span>\npublic<\/span>:\n    using<\/span> value_type = T;\n    using<\/span> difference_type = std<\/span>::ptrdiff_t<\/span>;\n    using<\/span> pointer = T*;\n    using<\/span> reference = T&;\n    using<\/span> iterator_category = std<\/span>::random_access_iterator_tag;\n\n    RandomAccessIterator(pointer ptr) : m_ptr(ptr) {}\n\n    reference operator<\/span>*() const<\/span> { return<\/span> *m_ptr; }\n    pointer operator<\/span>->() { return<\/span> m_ptr; }\n\n    RandomAccessIterator& operator<\/span>++() {\n        m_ptr++;\n        return<\/span> *this<\/span>;\n    }\n\n    RandomAccessIterator operator<\/span>++(int<\/span>) {\n        RandomAccessIterator tmp = *this<\/span>;\n        ++(*this<\/span>);\n        return<\/span> tmp;\n    }\n\n    RandomAccessIterator& operator<\/span>--() {\n        m_ptr--;\n        return<\/span> *this<\/span>;\n    }\n\n    RandomAccessIterator operator<\/span>--(int<\/span>) {\n        RandomAccessIterator tmp = *this<\/span>;\n        --(*this<\/span>);\n        return<\/span> tmp;\n    }\n\n    RandomAccessIterator operator<\/span>+(difference_type n) const<\/span> {\n        return<\/span> RandomAccessIterator(m_ptr + n);\n    }\n\n    RandomAccessIterator operator<\/span>-(difference_type n) const<\/span> {\n        return<\/span> RandomAccessIterator(m_ptr - n);\n    }\n\n    difference_type operator<\/span>-(const<\/span> RandomAccessIterator& other\n\n) const<\/span> {\n        return<\/span> m_ptr - other.m_ptr;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>==(const<\/span> RandomAccessIterator& a, const<\/span> RandomAccessIterator& b) {\n        return<\/span> a.m_ptr == b.m_ptr;\n    }\n\n    friend<\/span> bool<\/span> operator<\/span>!=(const<\/span> RandomAccessIterator& a, const<\/span> RandomAccessIterator& b) {\n        return<\/span> a.m_ptr != b.m_ptr;\n    }\n\nprivate<\/span>:\n    pointer m_ptr;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      7. Testing and Debugging Iterators<\/h2>\n\n\n\n
      Testing iterators involves checking their behavior with STL algorithms and custom loops. Use unit tests to verify that your iterator behaves as expected in various scenarios.<\/p>\n\n\n\n
      Example Test<\/h3>\n\n\n
      #include<\/span> <cassert><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n\nvoid<\/span> test_simple_iterator<\/span>()<\/span> <\/span>{\n    SimpleContainer<int<\/span>> container = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n    auto<\/span> it = container.begin();\n    assert(*it == 1<\/span>);\n    ++it;\n    assert(*it == 2<\/span>);\n    it++;\n    assert(*it == 3<\/span>);\n    std<\/span>::for_each(container.begin(), container.end(), [](int<\/span> &n) { n *= 2<\/span>; });\n    assert(*(container.begin()) == 2<\/span>);\n    assert(*(++container.begin()) == 4<\/span>);\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    test_simple_iterator();\n    std<\/span>::cout<\/span> << \"All tests passed!\"<\/span> << std<\/span>::endl<\/span>;\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      8. Best Practices<\/h2>\n\n\n\n
        \n
      • Follow STL Conventions<\/strong>: Ensure your iterators follow the STL conventions for compatibility with standard algorithms.<\/li>\n\n\n\n
      • Iterator Traits<\/strong>: Define the necessary iterator traits for your custom iterator.<\/li>\n\n\n\n
      • Increment and Decrement<\/strong>: Implement both prefix and postfix increment and decrement operators where applicable.<\/li>\n\n\n\n
      • Equality and Inequality<\/strong>: Implement operator==<\/code> and operator!=<\/code> to compare iterators.<\/li>\n\n\n\n
      • Testing<\/strong>: Thoroughly test your iterators with various STL algorithms and custom tests to ensure correctness.<\/li>\n<\/ul>\n\n\n\n
        9. Conclusion<\/h2>\n\n\n\n
        Custom iterators are powerful tools for creating seamless and efficient traversal mechanisms for your custom data structures. By adhering to the conventions and implementing the necessary operations, you can create iterators that integrate smoothly with the C++ Standard Library. This tutorial covered the basics of creating custom iterators, from defining iterator traits to implementing various types of iterators. With practice and careful design, you can leverage custom iterators to enhance the usability and performance of your custom containers in C++.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection, such as arrays, vectors, lists, and more. Custom iterators are essential when you create your own data structures and want them to work seamlessly with the standard algorithms provided by the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9,4],"tags":[],"class_list":["post-1965","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nHow to Implement Custom Iterators in C++<\/title>\n<meta name=\"description\" content=\"Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Implement Custom Iterators in C++\" \/>\n<meta property=\"og:description\" content=\"Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-22T09:53:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-06-22T09:53:05+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Implement Custom Iterators in C++\",\"datePublished\":\"2024-06-22T09:53:00+00:00\",\"dateModified\":\"2024-06-22T09:53:05+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/\"},\"wordCount\":619,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/\",\"name\":\"How to Implement Custom Iterators in C++\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-06-22T09:53:00+00:00\",\"dateModified\":\"2024-06-22T09:53:05+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-custom-iterators-in-cpp\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"How to Implement Custom Iterators in C++\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Implement Custom Iterators in C++","description":"Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/","og_locale":"en_US","og_type":"article","og_title":"How to Implement Custom Iterators in C++","og_description":"Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection","og_url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/","article_published_time":"2024-06-22T09:53:00+00:00","article_modified_time":"2024-06-22T09:53:05+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Implement Custom Iterators in C++","datePublished":"2024-06-22T09:53:00+00:00","dateModified":"2024-06-22T09:53:05+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/"},"wordCount":619,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/","url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/","name":"How to Implement Custom Iterators in C++","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-06-22T09:53:00+00:00","dateModified":"2024-06-22T09:53:05+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Iterators in C++ are a fundamental part of the Standard Template Library (STL). They provide a uniform way to access elements of a collection","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-custom-iterators-in-cpp\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"How to Implement Custom Iterators in C++"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1965","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1965"}],"version-history":[{"count":2,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1965\/revisions"}],"predecessor-version":[{"id":1967,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1965\/revisions\/1967"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1965"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1965"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1965"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}