Creating Custom Iterators using C++20 Concepts

Overloading Operators for Custom Iterators

Which operators should I overload for my custom iterator in C++?

Abstract art representing computer programming

For a custom iterator in C++, you typically need to overload several operators to ensure it behaves correctly in various contexts. The essential operators to overload include:

Dereference Operator *: Allows access to the element the iterator points to.
Increment Operator ++: Moves the iterator to the next element.
Equality Operator ==: Compares two iterators for equality.
Inequality Operator !=: Compares two iterators for inequality.
Postfix Increment Operator ++(int): Differentiated by an int parameter to distinguish it from the prefix increment.

Here’s an example implementation for a custom Iterator class:

1#include <iostream>
2#include <string>
3#include <stdexcept>
4
5class Player {
6public:
7  std::string Name;
8};
9
10class Party {
11public:
12  Party(Player A, Player B, Player C)
13    : A{A}, B{B}, C{C} {}
14
15  Player A, B, C;
16
17  class Iterator {
18  public:
19    using iterator_category
20      = std::forward_iterator_tag;
21    using value_type = Player;
22    using difference_type = std::ptrdiff_t;
23    using pointer = Player*;
24    using reference = Player&;
25
26    Iterator(Party* ptr = nullptr, size_t idx = 0) 
27      : Party(ptr), idx(idx) {}
28
29    Player& operator*() const {
30      if (idx == 0) return Party->A;
31      if (idx == 1) return Party->B;
32      if (idx == 2) return Party->C;
33      throw std::out_of_range("Invalid index");
34    }
35
36    Player* operator->() const {
37      return &**this;
38    }
39
40    Iterator& operator++() {
41      ++idx;
42      return *this;
43    }
44
45    Iterator operator++(int) {
46      Iterator tmp = *this;
47      ++(*this);
48      return tmp;
49    }
50
51    bool operator==(const Iterator& other) const {
52      return Party == other.Party && idx == other.idx;
53    }
54
55    bool operator!=(const Iterator& other) const {
56      return !(*this == other);
57    }
58
59  private:
60    size_t idx;
61    Party* Party;
62  };
63
64  Iterator begin() { return Iterator(this, 0); }
65  Iterator end() { return Iterator(this, 3); }
66};
67
68int main() {
69  Party party{Player{"Anna"},
70    Player{"Bob"}, Player{"Cara"}};
71
72  for (Player& p : party) {
73    std::cout << p.Name << ", ";
74  }
75
76  auto it = party.begin();
77  std::cout << '\n' << (it++)->Name;  
78  std::cout << '\n' << (it++)->Name;  
79  std::cout << '\n' << it->Name;      
80}

1Anna, Bob, Cara,
2Anna
3Bob
4Cara

Explanation

Dereference Operator *: Returns a reference to the Player object the iterator points to.
Prefix Increment Operator ++: Advances the iterator by incrementing the index.
Postfix Increment Operator ++(int): Similar to the prefix version but returns the iterator's state before the increment.
Equality and Inequality Operators (==, !=): Compare iterators based on their pointers and indices.

Overloading these operators ensures that your custom iterator can be used in standard C++ idioms, such as range-based for loops and algorithms from the Standard Library.

This Question is from the Lesson: