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 generally aren't going to be interacted with on the terminal, Command Line Interfaces (CLIs) are 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 to update the existing output on the screen, rather than appending new information below the old.

Clearing the Terminal using System Calls

A common technique to accomplish this is to clear the terminal before sending our next output. To clear the terminal, we can send commands to the underlying operating system, using the system() function.

For example, when using the Windows command prompt, we can clear the screen by typing the command "cls" and pressing enter.

Within our C++ program, we can trigger this same behavior by calling system("cls"):

1void ClearScreen() {
2  system("cls");
3}

In Linux and macOS, the equivalent command is "clear". When we're building for Windows, the compiler defines the _WIN32 preprocessor directive, which we can use to ensure our code is sending the correct system command:

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

A Practical Example

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
6void ClearScreen() {
7#if defined _WIN32
8  system("cls");
9#elif
10  system("clear");
11#endif
12}
13
14int main() {
15  using namespace std::chrono;
16  while (true) {
17    std::string Time{std::format(
18      "Time: {:%H:%M:%OS}", system_clock::now()
19    )};
20
21    ClearScreen();
22    std::cout << Time;
23    std::this_thread::sleep_for(seconds(1));
24  }
25}

1Time: 21:24:50

Flickering and Double Buffering

If we expand this technique to implement more elaborate rendering, we're likely to start noticing flickering effects. This is caused because rendering output takes time, and for the duration between clearing the terminal and generating the next output, there would be nothing on the screen at all.

This can be minimized simply by minimizing the amount of work that the user's system needs to do between clearing the screen and drawing the next screen.

To eliminate the problem entirely, we'd need to rely on a technique called double buffering. We can think of a buffer as the canvas where we're drawing our output:

the "front" buffer is being shown to the user
the "back" buffer is hidden from the user and is where we're building the next output (or frame) to be shown to the user

The front buffer is shown until the back buffer is ready, and then they get swapped around. The back buffer becomes the front buffer and is shown to the user, and the previous front buffer becomes the back buffer, where we start generating the next frame.

Using this technique, the user only ever sees complete frames. We cover this and other techniques for improving our visual output in the next course.

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.

Summary

In this lesson, we explored how to enhance terminal interfaces by using system calls to clear the screen. This fundamental technique not only improves the user experience for CLI tools but also sets a foundation for more advanced UI management in programming.

Key Takeaways:

Learned how to use system() function to execute system-specific commands like cls for Windows and clear for Linux/macOS.
Understood the use of preprocessor directives to ensure cross-platform compatibility in clearing the terminal.
Developed a simple clock application to apply the concept of clearing the terminal screen.
Gained insight into the challenges of flickering in terminal output and an introduction to the concept of double buffering.
Prepared the groundwork for more advanced topics like interactive user interfaces and handling user inputs.

System Calls and Terminal Management

Clearing the Terminal using System Calls

A Practical Example

Summary

User Input in the Terminal

Intro to C++ Programming