User Input in the Terminal

Up until now, our C++ programs have been running on their own, without any interaction from users. But what if we want to create more dynamic and responsive software?

In this lesson, we'll explore how to capture user input, allowing our programs to adapt and respond to the choices made by those using them.

This is a crucial step in creating interactive applications, from simple command-line tools to complex games and utilities.

Using std::cin and std::getline

Just like std::cout is a stream of output, std::cin is a stream of input from our user. Just like std::cout, it is also available within the <iostream> header

There are numerous ways to interact with std::cin. The most straightforward is using std::getline to get a line of text from our users.

std::getline is part of <string> and accepts two arguments:

• The input stream, representing where the data is coming from. To let the user input text in the terminal, we’d use std::cin for this.
• A reference to a std::string, which will be populated with what the user entered.

Below, we show this in action:

1#include <iostream>
2#include <string>
3
4int main() {
5  std::string UserInput;
6
7  std::cout << "Enter some text: ";
8  std::getline(std::cin, UserInput);
9  std::cout << "You entered: " << UserInput;
10}

Now, our program will pause at the std::getline call, and wait for user input. Typing something on our keyboard and hitting return will yield output like the following:

1Enter some text: Hello!
2You entered: Hello!

A Practical Example

Let's see a bigger example of this. The following code lets our users pick what type of Character they want to play as:

1#include <iostream>
2#include <string>
3
4class Character {
5public:
6  Character(const std::string& ClassName)
7	: ClassName { ClassName } {
8  }
9  void SetName(const std::string& NewName) {
10	Name = NewName;
11  }
12  std::string Name;
13  std::string ClassName;
14};
15
16class Warrior : public Character {
17public:
18  Warrior() : Character("Warrior") {}
19};
20
21class Rogue : public Character {
22public:
23  Rogue() : Character("Rogue") {}
24};
25
26class Wizard : public Character {
27public:
28  Wizard() : Character("Wizard") {}
29};
30
31std::string SelectClass() {
32  std::cout << "What class do you want to play?"
33    << "\n- Enter 1 for Warrior"
34    << "\n- Enter 2 for Rogue"
35    << "\n- Enter 3 for Wizard"
36    << "\n\nMake your selection: ";
37
38  std::string ClassString;
39  std::getline(std::cin, ClassString);
40  return ClassString;
41}
42
43std::string SelectName() {
44  std::cout << "Enter your name: ";
45
46  std::string Name;
47  std::getline(std::cin, Name);
48  return Name;
49}
50
51int main() {
52  Character* PlayerCharacter;
53  Warrior PlayerWarrior;
54  Rogue PlayerRogue;
55  Wizard PlayerWizard;
56
57  std::string SelectedClass{SelectClass()};
58  if (SelectedClass == "1") {
59	  PlayerCharacter = &PlayerWarrior;
60  } else if (SelectedClass == "2") {
61	  PlayerCharacter = &PlayerRogue;
62  } else {
63	  PlayerCharacter = &PlayerWizard;
64  }
65
66  PlayerCharacter->SetName(SelectName());
67
68  std::cout
69    << PlayerCharacter->Name << " the "
70    << PlayerCharacter->ClassName
71    << " is entering the arena!";
72}

After running this code, and providing the requested input, we might see something like this:

1What class do you want to play?
2- Enter 1 for Warrior
3- Enter 2 for Rogue
4- Enter 3 for Wizard
5
6Make your selection: 2
7Enter your name: Grifter
8Grifter the Rogue is entering the arena!

Summary

In this lesson, we explored the basics of obtaining user input in C++ using std::cin and std::getline. Through practical examples, we learned how to make our programs interactive and responsive to user commands.

Preview of the Next Lesson

In the upcoming lesson, we'll delve into bitwise operators and bit flags. This topic involves manipulating data at the binary level, which is essential for certain types of low-level programming, optimization, and handling of compact data structures. We’ll cover:

• Binary Basics and Object Representation: Gain an understanding of binary numbers and how data is represented as a series of binary digits, or bits.
• Understanding Bitwise Operators: Learn about bitwise AND, OR, XOR, NOT, and how they are used to manipulate individual bits.
• Bit Flags and Bit Masks: Explore how to use bitwise operators to create and manipulate sets of options, often known as bit flags.
• Shifting Bits: Understand the use of left and right shift operators and their impact on data.
• Practical Applications: See real-world examples of how bitwise operations are used in areas like graphics programming, system programming, and optimizing memory usage.

Next Lesson

Bitwise Operators and Bit Flags

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

ContinueView Course