System Calls and Terminal Management

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

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.

Preview of the Next Lesson

In the upcoming lesson, we will dive into the interactive aspect of command line interfaces by focusing on getting user input in the terminal.

Key Topics for the Next Lesson:

• Introduction to standard input (std::cin) and how it works.
• Using std::getline to get input from the user.
• Practical examples demonstrating the implementation of user input.

Next Lesson

User Input in the Terminal

This lesson introduces the fundamentals of capturing user input, using std::cin and std::getline

ContinueView Course