Overloading the << Operator

So far, we've been using a simple terminal prompt to view the output of our program. Later in this course, we'll switch to rendering graphics using SDL.

But, there are some useful tricks we have that can help us make the most of our terminal for building out quick programs.

We've seen how we can stream numbers and strings to the terminal using the << operator:

1std::cout << "Hello World " << 42;

We'd like to be able to do something similar with our custom objects. For example:

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/}
10
11int main() {
12  Character Enemy;
13  std::cout << Enemy;
14}

To do this, we need to overload the << operator to be usable with std::cout as the left operand, and Character as the right operand.

Inspecting that in our IDE, or checking the documentation, would reveal it to be a std::ostream, which is an output stream.

Because std::cout is the left operand, the std::ostream reference needs to be the first argument for our overload, whilst the Character& is the second argument. So, our overload would look like this:

1void operator<< (
2  std::ostream& Stream,
3  const Character& Enemy
4) {
5  Stream << "Hello World";
6}

With that, our code will now compile, with "Hello World" being streamed to the terminal:

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/}
10
Operator Overload|Show
11void operator<<(std::ostream&, const Character&)
18
19int main() {
20  Character Enemy;
21  std::cout << Enemy;
22}

1Hello World

We want to make two updates to make our overload more useful. Firstly, we want to be able to chain << operators, just like we can when streaming other types. For example, we want to be able to do things like this:

1std::cout << MyCharacter << '\n';

To enable this, we need to ensure our overload function returns a reference to the stream we're writing to. So, we update the return type of our overload, and return the stream that was used as the left operand:

1std::ostream& operator<<(
2  std::ostream& Stream,
3  const Character& Enemy
4) {
5  Stream << "Hello World";
6  return Stream;
7}

With that, we can now chain additional << operators after streaming a Character object:

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/}
10
Operator Overload|Show
11void operator<<(std::ostream&, const Character&)
18
19int main() {
20  Character Enemy;
21  std::cout << Enemy << "!!!";
22}

1Hello World!!!

Secondly, we want our Character output to generate some meaningful output, so we can stream it rather than "Hello World".

Representing the state of objects as a simple string is sometimes referred to as serialization. We'll see more of this in the next course, as it unlocks features like saving files to the user's hard drive and communicating over the internet, enabling programs like multiplayer games.

For now, we can just create a simple function that generates a string that stores some info about our object, in this format:

1[Level] Name (Health / MaxHealth)

To accomplish this, we could add a public function that uses the std::format techniques we covered in the previous lesson:

1class Character {
2public:
3  std::string Serialize() const {
4    return std::format(
5      "[Level {}] {} ({} / {})",
6      Level, Name, Health, MaxHealth);
7  }
8private:
9  std::string Name { "Goblin Warrior" };
10  int Level { 15 };
11  int MaxHealth { 150 };
12  int Health { 90 };
13};

Finally, let's update our overload to use this function:

1std::ostream& operator<<(
2  std::ostream& Stream,
3  const Character& Enemy
4) {
5  Stream << Enemy.Serialize();
6  return Stream;
7}

With that, everything is in place. Developers can now easily stream information about our objects to std::cout like any other type:

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/}
18
Operator Overload|Show
19void operator<<(std::ostream&, const Character&)
27
28int main() {
29  Character Enemy;
30  std::cout << Enemy;
31}

1[Level 15] Goblin Warrior (90 / 150)

In this lesson, we explored how to overload the << operator in C++, enabling us to stream custom objects directly to the console using std::cout. Through practical examples, we demonstrated chaining operators and serializing objects for more effective output. Key topics included:

• Understanding the concept and implementation of overloading the << operator for user-defined types.
• Learning how to make the overloaded operator compatible with std::cout by using std::ostream& and a reference to our custom type as parameters.
• Exploring the technique of chaining << operators by returning a reference to the stream.
• An introduction to object serialization, through implementing a Serialize method in our class.