Range Based For Loops with Custom Types

Previously, we saw how we could use range-based for loops with any type that has appropriate begin and end methods, such as std::vector and std::forward_list.

It stands to reason, therefore, that we should be able to make our own types compatible with range-based for loops.

We may want to do something like this:

1class Character {};
2class Party {};
3
4int main() {
5  Party MyParty;
6  for (const auto& Character : MyParty) {
7    // ...
8  }
9}
10

Lets see how we can set this up.

Adding iterators to our custom types

In the next lesson, we will see an example where we create iterators entirely from scratch. But, in most cases, this is entirely unnecessary.

The most typical scenario is that our custom type has some functions and variables specific to our type, but is using a container for storage that already supports iterators.

This might be an array, vector, or linked list, for example.

A typical Party class might look a little like this:

1#include <vector>
2
3class Character {};
4
5class Party {
6public:
7  // Party-specific logic
8  void AddMember() {};
9  void StartQuest() {};
10  void Disband() {};
11  void SetLeader() {};
12
13private:
14  // Underlying Collection
15  std::vector<Character> PartyMembers;
16};
17

To make our party iterable, we can just expose the begin and end methods of our underlying container. Note, our begin and end methods must be public for this to work:

1#include <vector>
2
3class Character {};
4
5class Party {
6public:
7  // Party-specific logic
8  // ...
9
10  // Iterators
11  auto begin() {
12    return PartyMembers.begin();
13  }
14  auto end() {
15    return PartyMembers.end();
16  }
17private:
18  // Underlying Collection
19  vector<Character> PartyMembers;
20};
21

Iterator Types

Above, the return type of our new functions was set to auto. This is typical, but if we ever need to be specific about the type of an iterator from the standard library containers, there’s a static iterator property that we can use:

1vector<Character>::iterator begin() {
2  return PartyMembers.begin();
3}
4
5vector<Character>::iterator end() {
6  return PartyMembers.end();
7}
8

Using Range-Based For Loops

With the public begin and end methods added to our class, the code in our original example will now work. This allows us to iterate over every character in our party using a range-based for loop:

1int main() {
2  Party MyParty;
3
4  for (const auto& Character : MyParty) {
5    // ...do things
6  }
7}
8

A complete example is available here:

1#include <vector>
2#include <iostream>
3#include <utility>
4using namespace std;
5
6class Character {
7public:
8  Character(string Name) : Name(std::move(Name)) {}
9  string GetName() const { return Name; }
10private:
11  string Name;
12};
13
14class Party {
15public:
16  void AddMember(const string& NewMember) {
17    PartyMembers.emplace_back(NewMember);
18  }
19
20  // Iterators
21  auto begin() {
22    return PartyMembers.begin();
23  }
24  auto end() {
25    return PartyMembers.end();
26  }
27private:
28  vector<Character> PartyMembers;
29};
30
31int main() {
32  Party MyParty;
33  MyParty.AddMember("Legolas");
34  MyParty.AddMember("Gimli");
35  MyParty.AddMember("Frodo");
36
37  for (const auto& Character : MyParty) {
38    cout << Character.GetName() << endl;
39  }
40}
41

1Legolas
2Gimli
3Frodo
4

Updating our class to support iterators also means they can be used in other ways, which we’ll explore fully in the algorithm chapter later in this course.