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.

Overloading the << Operator

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

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

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

1#include <iostream>
2using namespace std;
3
4class Character {
5    string Name { "Goblin Warrior" };
6    int Level { 15 };
7    int MaxHealth { 150 };
8    int Health { 90 };
9};
10
11int main() {
12    Character MyCharacter;
13    std::cout << MyCharacter;
14}
15

To do this, we need to overload the << operator. Because we're calling << on the left operand, we need to overload it on the object type that is returned from std::cout.

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

So, our overload would look like this:

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

Now, attempting to stream out a character will result in "Hello World" being streamed to the terminal.

1Character MyCharacter;
2std::cout << MyCharacter;
3

1Hello World
2

We want to make two changes here:

Firstly, we want to be able to chain << operators. We'd like to do things like this:

1std::cout << MyCharacter <<  std::endl;
2

To enable this, we need to make sure our function returns a reference to the stream we're writing to, so we can stream additional things to it. So, we update the return type of our function, and return the stream:

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

With that, our code works:

1Character MyCharacter;
2std::cout << MyCharacter << "!!!";
3

1Hello World!!!
2

Secondly, we want to stream out something that is appropriate to our character, rather than "Hello World".

A useful way of doing this is by adding a public method to our class. Lets imagine we wanted to log out this:

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

To accomplish this, our new Character.Write() method might look something like this:

1class Character {
2public:
3  void Write(std::ostream& Stream) {
4    Stream << "[Level " << Level << "] ";
5    Stream << Name;
6    Stream << " (" << Health << " / " << MaxHealth << ")";
7  }
8private:
9  std::string Name { "Goblin Warrior" };
10  int Level { 15 };
11  int MaxHealth { 150 };
12  int Health { 90 };
13};
14

Finally, lets update our overload to use this function:

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

Now, info about our characters can be streamed directly to our terminal:

1std::cout << PlayerCharacter <<  std::endl;
2std::cout << EnemyCharacter <<  std::endl;
3

Clearing the Terminal

Soon, we'll be working with libraries that help us create fully interactive user interfaces. But, before we move on to that, it's worth quickly covering how we can improve the terminal output.

Even though the products we ship to users aren't going to be interacted with on the terminal, Command Line Interface (CLI) is very common for internal tools, intended to be used by other developers.

Currently, our output has always been a vertical stream of text. Typically, a better user experience is update the existing output on the screen, rather than appending new information below the old.

A common technique to accomplish this is to clear the screen and redraw the new output.

There are several ways to clear a terminal, and it varies from operating system to operating system. Below is a simple example that works on Windows, Linux and Apple devices:

1void ClearScreen() {
2#if defined _WIN32
3  system("cls");
4#elif
5  system("clear");
6#endif
7}
8

We can use this to create a simple clock application, that updates every second:

1#include <chrono>
2#include <iomanip>
3#include <iostream>
4#include <thread>
5
6using namespace std;
7using namespace std::chrono;
8
9void ClearScreen() {
10#if defined _WIN32
11  system("cls");
12#elif
13  system("clear");
14#endif
15}
16
17void PrintTime(const time_t& Time) {
18  tm TimeContainer;
19  localtime_r(&Time, &TimeContainer);
20
21  cout << put_time(&TimeContainer, "%r") << endl;
22}
23
24int main() {
25  while (true) {
26    time_point Time{system_clock::now()};
27    ClearScreen();
28    PrintTime(system_clock::to_time_t(Time));
29
30    this_thread::sleep_for(seconds(1));
31  }
32}
33

Next, we'll see how we can extend our use of the terminal to get input from our users, letting our software react to their input!