Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Booleans - `true` and `false` values

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

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

User Input in the Terminal

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

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

Yes, you can change the color and formatting of the input prompt in the console using C++.


However, the method to do this is platform-dependent. We'll explore how to do this for both Windows and Unix-like systems (Linux, macOS), and then provide a cross-platform solution.


## Windows Implementation


On Windows, we can use the `SetConsoleTextAttribute()` function from the Windows API to change text color:


```c++
#include <iostream>
#include <string>
#include <windows.h>

void setColor(int color){
  SetConsoleTextAttribute(
    GetStdHandle(STD_OUTPUT_HANDLE),
    color);
}

int main(){
  setColor(FOREGROUND_RED |
    FOREGROUND_INTENSITY); // Bright red
  std::cout << "Enter your name: ";
  setColor(FOREGROUND_GREEN | FOREGROUND_BLUE |
    FOREGROUND_INTENSITY); // Cyan

  std::string name;
  std::getline(std::cin, name);

  setColor(FOREGROUND_RED | FOREGROUND_GREEN |
    FOREGROUND_BLUE); // White
  std::cout << "Hello, " << name << "!\n";
}
```


<CustomOutput>


<div><Red>Enter your name:</Red> <Cyan>Ryan</Cyan></div>
<div><White>Hello, Ryan!</White></div>


</CustomOutput>


In this Windows example, we define a `setColor()` function that uses `SetConsoleTextAttribute()` to change the console text color. We use different color combinations for the prompt and the input.


## Unix-like Systems Implementation


For Unix-like systems, we can use [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) to change text color:


```c++
#include <iostream>
#include <string>

// ANSI color codes
#define RESET "\033[0m"
#define RED "\033[31m"
#define GREEN "\033[32m"
#define BLUE "\033[34m"
#define CYAN "\033[36m"

int main(){
  std::cout << RED << "Enter your name: " <<
    CYAN;

  std::string name;
  std::getline(std::cin, name);

  std::cout << RESET << "Hello, " << GREEN <<
    name << RESET
    << "!\n";
}
```


<CustomOutput>


<div><Red>Enter your name:</Red> <Cyan>Ryan</Cyan></div>
<div><White>Hello, </White><Green>Ryan!</Green></div>


</CustomOutput>


In this Unix-like system example, we use ANSI escape codes to change text colors. These codes are supported by most modern terminal emulators.


## Cross-platform Solution


To create a cross-platform solution, we can use conditional compilation and create a simple Color enum:


```c++
#include <iostream>
#include <string>

enum class Color {
  Red,
  Green,
  Blue,
  Cyan,
  Reset
};

#ifdef _WIN32
#include <windows.h>

void setColor(Color color){
  HANDLE hConsole = GetStdHandle(
    STD_OUTPUT_HANDLE);
  switch (color) {
  case Color::Red:
    SetConsoleTextAttribute(
      hConsole,
      FOREGROUND_RED | FOREGROUND_INTENSITY);
    break;
  case Color::Green:
    SetConsoleTextAttribute(
      hConsole,
      FOREGROUND_GREEN | FOREGROUND_INTENSITY);
    break;
  case Color::Blue:
    SetConsoleTextAttribute(
      hConsole,
      FOREGROUND_BLUE | FOREGROUND_INTENSITY);
    break;
  case Color::Cyan:
    SetConsoleTextAttribute(
      hConsole,
      FOREGROUND_GREEN | FOREGROUND_BLUE |
      FOREGROUND_INTENSITY);
    break;
  case Color::Reset:
    SetConsoleTextAttribute(
      hConsole,
      FOREGROUND_RED | FOREGROUND_GREEN |
      FOREGROUND_BLUE);
    break;
  }
}
#else
void setColor(Color color) {
  switch (color) {
    case Color::Red:
      std::cout << "\033[31m";
      break;
    case Color::Green:
      std::cout << "\033[32m";
      break;
    case Color::Blue:
      std::cout << "\033[34m";
      break;
    case Color::Cyan:
      std::cout << "\033[36m";
      break;
    case Color::Reset:
      std::cout << "\033[0m";
      break;
  }
}
#endif

int main(){
  setColor(Color::Red);
  std::cout << "Enter your name: ";
  setColor(Color::Cyan);

  std::string name;
  std::getline(std::cin, name);

  setColor(Color::Reset);
  std::cout << "Hello, ";
  setColor(Color::Green);
  std::cout << name;
  setColor(Color::Reset);
}
```


<CustomOutput>


<div><Red>Enter your name:</Red> <Cyan>Ryan</Cyan></div>
<div><White>Hello, </White><Green>Ryan!</Green></div>


</CustomOutput>


This cross-platform solution uses conditional compilation to choose the appropriate color-setting method based on the target platform. It provides a consistent interface for changing text colors across different operating systems.


Remember that color support can vary depending on the terminal or console application being used. Some environments may not support colors at all, while others might support a wider range of colors than what's shown here.


Also, keep in mind that changing text colors should be used judiciously. Overuse can make your application harder to read or use, especially for users with visual impairments. Always consider accessibility when designing your user interface.

Changing Console Input Color in C++

Formatting console output can greatly enhance the user experience of your C++ applications. There are several techniques you can use to create more visually appealing displays. Let's explore some of these methods:


## 1. Using Escape Sequences


Escape sequences allow you to control cursor position and clear the screen:


```c++
#include <iostream>

int main(){
  // Clear screen
  std::cout << "\033[2J\033[1;1H";

  // Move cursor to row 5, column 10
  std::cout << "\033[5;10H"
    << "Hello, World!";

  // Move cursor down 2 lines and right 5 spaces
  std::cout << "\033[2B\033[5C"
    << "Welcome to C++!";
}
```


This example demonstrates clearing the screen, positioning the cursor, and moving it relative to its current position.


## 2. Creating Boxes and Lines


You can use ASCII characters to create boxes and lines:


```c++
#include <iostream>
#include <iomanip>

void drawBox(int width, int height){
  std::cout << "" << std::string(
    width - 2, '─') << "\n";
  for (int i = 0; i < height - 2; ++i) {
    std::cout << "│" << std::string(
        width - 2, ' ')
      << "│\n";
  }
  std::cout << "└" << std::string(
    width - 2, '─') << "\n";
}

int main(){
  drawBox(20, 5);

  // Position text inside the box
  std::cout << "\033[3;3H"
    << "Hello, World!";

  std::cout << std::endl;
}
```


This creates a simple box using ASCII characters and positions text inside it.


```plain text
//<o>
──────────────────
│                  │
│  Hello, World!   │
│                  │
└──────────────────
```


## 3. Using Color and Text Styling


As we saw in the previous answer, you can use ANSI escape codes for color and text styling:


```c++
#include <iostream>

#define RESET "\033[0m"
#define BOLD "\033[1m"
#define RED "\033[31m"
#define GREEN "\033[32m"
#define BLUE "\033[34m"
#define CYAN "\033[36m"

int main(){
  std::cout << BOLD << RED << "Error: " << RESET
    << "Something went wrong!\n";
  std::cout << GREEN << "Success: " << RESET
    << "Operation completed.\n";
  std::cout << BLUE << "Info: " << RESET
    << "This is some information.\n";
  std::cout << CYAN << "Debug: " << RESET
    << "Variable x = 42\n";
}
```


<CustomOutput>


<div><Red>Error: </Red><White>Something went wrong!</White></div>


<div><Green>Success: </Green><White>Operation completed.</White></div>


<div><Blue>Info: </Blue><White>This is some information.</White></div>


<div><Cyan>Debug: </Cyan><White>Variable x = 42</White></div>


</CustomOutput>


This example shows how to use different colors and text styles to highlight different types of messages.


## 4. Creating Tables


You can use `std::setw` and `std::setfill` to create aligned tables:


```c++
#include <iostream>
#include <iomanip>

int main(){
  std::cout << std::setfill('-') <<
    std::setw(40)
    << "-" << std::endl;

  std::cout << std::setfill(' ');

  std::cout << "| " << std::left <<
    std::setw(20)
    << "Name" << "| " << std::right <<
    std::setw(15)
    << "Score"
    << " |" << std::endl;

  std::cout << std::setfill('-') <<
    std::setw(40) << "-"
    << std::endl;

  std::cout << std::setfill(' ');

  std::cout << "| " << std::left <<
    std::setw(20) << "Alice"
    << "| " << std::right << std::setw(15) << 95
    << " |" << std::endl;

  std::cout << "| " << std::left <<
    std::setw(20) << "Bob"
    << "| " << std::right << std::setw(15) << 87
    << " |" << std::endl;

  std::cout << "| " << std::left <<
    std::setw(20)
    << "Charlie"
    << "| " << std::right << std::setw(15) << 92
    << " |" << std::endl;

  std::cout << std::setfill('-') <<
    std::setw(40) << "-"
    << std::endl;
}
```


This creates a neatly formatted table with aligned columns.


```plain text
//<o>
----------------------------------------
| Name                |           Score |
----------------------------------------
| Alice               |              95 |
| Bob                 |              87 |
| Charlie             |              92 |
----------------------------------------
```


## 5. Progress Bars


You can create simple progress bars to show the status of long-running operations:


```c++
#include <iostream>
#include <thread>
#include <chrono>

void showProgress(int progress){
  int barWidth = 40;
  std::cout << "[";
  int pos = barWidth * progress / 100;
  for (int i = 0; i < barWidth; ++i) {
    if (i < pos) std::cout << "=";
    else if (i == pos) std::cout << ">";
    else std::cout << " ";
  }
  std::cout << "] " << progress << " %\r";
  std::cout.flush();
}

int main(){
  for (int i = 0; i <= 100; ++i) {
    showProgress(i);
    std::this_thread::sleep_for(
      std::chrono::milliseconds(50));
  }
}
```


This creates a progress bar that updates as an operation progresses.


```plain text
//<o>
[==================>           ] 58 %
```


## 6. Using Unicode Characters


Modern terminals often support Unicode, allowing for more graphical elements:


```c++
#include <iostream>

int main(){
  std::cout <<
    "Simple shapes:        \n";
  std::cout << "Card suits: ♠ ♥ ♦ ♣\n";
  std::cout << "Music notes: ♩ ♪ ♫ ♬\n";
  std::cout << "Arrows:     ↔ ↕\n";
}
```


This displays various Unicode characters that can be used to enhance your console output.


```plain text
//<o>
Simple shapes:        
Card suits: ♠ ♥ ♦ ♣
Music notes: ♩ ♪ ♫ ♬
Arrows:     ↔ ↕
```


Remember that the support for these formatting techniques can vary depending on the terminal or console application being used. Always test your application in the target environment to ensure compatibility.


Additionally, consider providing fallback options for environments that don't support advanced formatting to ensure your application remains usable across different platforms.

Formatting Console Output in C++

Handling password input securely, where characters are not displayed as they're typed, is an important feature for many applications.


In C++, this isn't as straightforward as in some other languages, but we can achieve it using platform-specific functions. Let's explore how to do this on both Windows and Unix-like systems (Linux, macOS).


## Windows Implementation


For Windows, we'll use the `_getch()` function from `<conio.h>`:


```c++
#include <iostream>
#include <string>
#include <conio.h>  // Windows-specific header

std::string getPassword(){
  std::string password;
  char ch;

  // Read until Enter is pressed
  while ((ch = _getch()) != '\r') {
    // Handle backspace
    if (ch == '\b') {
      if (!password.empty()) {
        std::cout << "\b \b";
        password.pop_back();
      }
    } else {
      password += ch;
      std::cout << '*';
    }
  }
  std::cout << '\n';
  return password;
}

int main(){
  std::cout << "Enter password: ";
  std::string password = getPassword();
  std::cout << "Password entered: " << password;
}
```


This Windows implementation uses `_getch()` to read characters without echoing them to the console. We print an asterisk for each character entered to provide visual feedback.


```plain text
//<o>
Enter password: ******
Password entered: secret
```


## Unix-like Systems Implementation


For Unix-like systems, we'll use the `termios.h` header to modify terminal attributes:


```c++
#include <iostream>
#include <string>
#include <termios.h>
#include <unistd.h>

std::string getPassword(){
  std::string password;
  termios oldt;
  tcgetattr(STDIN_FILENO, &oldt);
  termios newt = oldt;
  newt.c_lflag &= ~ECHO;
  tcsetattr(STDIN_FILENO, TCSANOW, &newt);

  char ch;
  while ((ch = getchar()) != '\n') {
    if (ch == 127) {
      // Handle backspace
      if (!password.empty()) {
        std::cout << "\b \b";
        password.pop_back();
      }
    } else {
      password += ch;
      std::cout << '*';
    }
  }
  std::cout << '\n';

  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  return password;
}

int main(){
  std::cout << "Enter password: ";
  std::string password = getPassword();
  std::cout << "Password entered: " << password;
}
```


```plain text
//<o>
Enter password: ******
Password entered: secret
```


In this Unix-like system implementation, we temporarily disable echo in the terminal, read characters one by one, and restore the original terminal settings afterwards.


## Cross-platform Solution


To create a cross-platform solution, you can use conditional compilation:


```c++
#include <iostream>
#include <string>

#ifdef _WIN32
#include <conio.h>
#else
#include <termios.h>
#include <unistd.h>
#endif

std::string getPassword(){
  std::string password;

#ifdef _WIN32
  // Windows implementation
  char ch;
  while ((ch = _getch()) != '\r') {
    if (ch == '\b') {
      if (!password.empty()) {
        std::cout << "\b \b";
        password.pop_back();
      }
    } else {
      password += ch;
      std::cout << '*';
    }
  }
#else
  // Unix-like implementation
  termios oldt;
  tcgetattr(STDIN_FILENO, &oldt);
  termios newt = oldt;
  newt.c_lflag &= ~ECHO;
  tcsetattr(STDIN_FILENO, TCSANOW, &newt);

  char ch;
  while ((ch = getchar()) != '\n') {
    if (ch == 127) {
      if (!password.empty()) {
        std::cout << "\b \b";
        password.pop_back();
      }
    } else {
      password += ch;
      std::cout << '*';
    }
  }

  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
#endif

  std::cout << '\n';
  return password;
}

int main(){
  std::cout << "Enter password: ";
  std::string password = getPassword();
  std::cout << "Password entered: " << password;
}
```


```plain text
//<o>
Enter password: ******
Password entered: secret
```


This cross-platform solution uses conditional compilation to choose the appropriate implementation based on the target platform.


Remember, while these methods hide password input from the screen, they don't provide complete security. For production systems, consider using secure password hashing algorithms and avoid storing plaintext passwords.

Secure Password Input in C++

Yes, it is possible to handle arrow key input in C++ for navigation purposes, but it requires some platform-specific code.


Arrow keys typically generate special key codes that we need to capture and interpret. Let's explore how to do this on both Windows and Unix-like systems.


## Windows Implementation


On Windows, we can use the `_getch()` function from `<conio.h>` to capture arrow key input:


```c++
#include <iostream>
#include <conio.h>  // Windows-specific header

int main(){
  std::cout <<
    "Use arrow keys to navigate:\n";

  while (true) {
    int dir = _getch();

    // Special key indicator
    if (dir == 0 || dir == 224) {
      switch (_getch()) {
      case 72:
        std::cout << "Up ";
        break;
      case 80:
        std::cout << "Down ";
        break;
      case 75:
        std::cout << "Left ";
        break;
      case 77:
        std::cout << "Right ";
        break;
      }
    } else { break; }
  }
}
```


```plain text
//<o>
Up Down Left Right
```


This Windows implementation uses `_getch()` to read key presses without echoing them to the console. Arrow keys generate two characters: a special key indicator (0 or 224) followed by the actual arrow key code.


## Unix-like Systems Implementation


For Unix-like systems, we can use the `termios.h` header to put the terminal in raw mode and capture individual key presses:


```c++
#include <iostream>
#include <termios.h>
#include <unistd.h>

enum class Direction {
  Up,
  Down,
  Left,
  Right,
  Unknown
};

termios orig_termios;

void disableRawMode(){
  tcsetattr(STDIN_FILENO, TCSAFLUSH,
            &orig_termios);
}

void enableRawMode(){
  tcgetattr(STDIN_FILENO, &orig_termios);
  atexit(disableRawMode);
  termios raw = orig_termios;
  raw.c_lflag &= ~(ECHO | ICANON);
  tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
}

Direction getArrowKeyInput(){
  char c;
  if (read(STDIN_FILENO, &c, 1) == 1) {
    if (c == '\x1b') {
      char seq[3];
      if (read(STDIN_FILENO, &seq[0], 1) !=
        1) return Direction::Unknown;
      if (read(STDIN_FILENO, &seq[1], 1) !=
        1) return Direction::Unknown;
      if (seq[0] == '[') {
        switch (seq[1]) {
        case 'A':
          return Direction::Up;
        case 'B':
          return Direction::Down;
        case 'C':
          return Direction::Right;
        case 'D':
          return Direction::Left;
        }
      }
    }
  }
  return Direction::Unknown;
}

int main(){
  enableRawMode();
  std::cout <<
    "Use arrow keys to navigate (press 'q' to "
    "quit):\n";
  char c;
  while (read(STDIN_FILENO, &c, 1) == 1 && c !=
    'q') {
    Direction dir = getArrowKeyInput();
    switch (dir) {
    case Direction::Up:
      std::cout << "Up ";
      break;
    case Direction::Down:
      std::cout << "Down ";
      break;
    case Direction::Left:
      std::cout << "Left ";
      break;
    case Direction::Right:
      std::cout << "Right ";
      break;
    default:
      break;
    }
  }
}
```


```plain text
//<o>
Up Down Left Right
```


This Unix-like implementation puts the terminal in raw mode to read individual key presses. Arrow keys generate a sequence of characters starting with the escape character ('\x1b').


## Cross-platform Solution


To create a cross-platform solution, you can use conditional compilation:


```c++
#include <iostream>

#ifdef _WIN32
#include <conio.h>
#else
#include <termios.h>
#include <unistd.h>
#endif

enum class Direction {
  Up,
  Down,
  Left,
  Right,
  Unknown
};

#ifndef _WIN32
termios orig_termios;

void disableRawMode() {
  tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
}

void enableRawMode() {
  tcgetattr(STDIN_FILENO, &orig_termios);
  atexit(disableRawMode);
  termios raw = orig_termios;
  raw.c_lflag &= ~(ECHO | ICANON);
  tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
}
#endif

Direction getArrowKeyInput(){
#ifdef _WIN32
  switch (_getch()) {
  case 72:
    return Direction::Up;
  case 80:
    return Direction::Down;
  case 75:
    return Direction::Left;
  case 77:
    return Direction::Right;
  default:
    return Direction::Unknown;
  }
#else
  char c;
  if (read(STDIN_FILENO, &c, 1) == 1) {
    if (c == '\x1b') {
      char seq[3];
      if (read(STDIN_FILENO, &seq[0], 1) != 1)
        return Direction::Unknown;
      if (read(STDIN_FILENO, &seq[1], 1) != 1)
        return Direction::Unknown;
      if (seq[0] == '[') {
        switch (seq[1]) {
          case 'A':
            return Direction::Up;
          case 'B':
            return Direction::Down;
          case 'C':
            return Direction::Right;
          case 'D':
            return Direction::Left;
        }
      }
    }
  }
#endif
  return Direction::Unknown;
}

int main(){
#ifndef _WIN32
  enableRawMode();
#endif
  std::cout <<
    "Use arrow keys to navigate (press 'q' to "
    "quit):\n";
  int ch;
  while (true) {
#ifdef _WIN32
    ch = _getch();
#else
    read(STDIN_FILENO, &ch, 1);
#endif
    if (ch == 'q') break;
    if (ch != 0 && ch != 224) continue;
    Direction dir = getArrowKeyInput();
    switch (dir) {
    case Direction::Up:
      std::cout << "Up\n";
      break;
    case Direction::Down:
      std::cout << "Down\n";
      break;
    case Direction::Left:
      std::cout << "Left\n";
      break;
    case Direction::Right:
      std::cout << "Right\n";
      break;
    default:
      break;
    }
  }
}
```


```plain text
//<o>
Up Down Left Right
```


This cross-platform solution uses conditional compilation to choose the appropriate implementation based on the target platform. It provides a consistent interface for handling arrow key input across different operating systems.


Remember that this low-level input handling can make your program less portable and more complex. For more advanced applications, consider using cross-platform libraries like ncurses or SDL that provide higher-level abstractions for keyboard input and terminal control.

Handling Arrow Key Input in C++

Validating user input is crucial for creating robust C++ programs. Here's a guide on how to ensure your input is of the correct data type:


## Using Error States


When reading input with `std::cin`, it sets error flags if the input doesn't match the expected type. We can use these flags to validate input:


```c++
#include <iostream>
#include <limits>

int main(){
  int userAge;

  while (true) {
    std::cout << "Enter your age: ";
    std::cin >> userAge;

    if (std::cin.fail()) {
      std::cin.clear(); // Clear error flags
      std::cin.ignore(//<h>
        std::numeric_limits<//<h>
          std::streamsize>::max(),//<h>
        '\n'); //<h>
      std::cout
        << "Invalid input. Please enter a number.\n";
    } else if (userAge <= 0 || userAge > 120) {
      std::cout <<
        "Age must be between 1 and 120.\n";
    } else {
      break; // Valid input, exit loop
    }
  }

  std::cout << "Your age is: " << userAge;
}
```


```plain text
//<o>
Enter your age: hi
Invalid input. Please enter a number.
Enter your age: 25
Your age is: 25
```


In this example, we use a while loop to repeatedly ask for input until it's valid. The `std::cin.fail()` check detects if the input wasn't an integer. If it fails, we clear the error flags and ignore the rest of the input line.


## Using String Input and Conversion


Another approach is to read input as a string and then convert it:


```c++
#include <iostream>
#include <string>
#include <stdexcept>

int main(){
  std::string input;
  int userAge;

  while (true) {
    std::cout << "Enter your age: ";
    std::getline(std::cin, input);

    try {
      userAge = std::stoi(input); //<h>
      if (userAge <= 0 || userAge > 120) {
        throw std::out_of_range(
          "Age out of valid range");
      }
      break; // Valid input, exit loop
    }
    catch (const std::invalid_argument&) {
      std::cout
        << "Invalid input. Please enter a number.\n";
    } catch (const std::out_of_range&) {
      std::cout <<
        "Age must be between 1 and 120.\n";
    }
  }

  std::cout << "Your age is: " << userAge;
}
```


```plain text
//<o>
Enter your age: hi
Invalid input. Please enter a number.
Enter your age: 25
Your age is: 25
```


This method uses `std::getline()` to read the entire input line, then `std::stoi()` to convert it to an integer. We catch exceptions to handle invalid input or out-of-range values.


Remember, input validation is about more than just checking data types. Always consider the range of acceptable values and any other constraints specific to your program's needs.

Validating User Input in C++

Yes, it's absolutely possible to input multiple values in a single line using `std::cin`.


This is actually one of the convenient features of `std::cin` - it can handle multiple inputs separated by whitespace (spaces, tabs, or newlines). Let's explore how to do this effectively:


## Basic Multiple Input


Here's a simple example of reading multiple values from a single line:


```c++
#include <iostream>
#include <string>

int main(){
  int age;
  std::string name;
  double height;

  std::cout <<
    "Enter your name, age, and height: ";
  std::cin >> name >> age >> height; //<h>

  std::cout << "Name: " << name << "\n";
  std::cout << "Age: " << age << "\n";
  std::cout << "Height: " << height <<
    " meters\n";
}
```


In this example, the user can enter something like "John 25 1.75" on a single line, and `std::cin` will distribute these values to the appropriate variables.


```plain text
//<o>
Enter your name, age, and height: John 25 1.75
Name: John
Age: 25
Height: 1.75 meters
```


## Handling Input with Spaces


The basic approach works well for simple types, but what if we want to input a full name with spaces? We can combine `std::cin` with `std::getline()`:


```c++
#include <iostream>
#include <string>
#include <sstream>

int main(){
  std::string fullName;
  int age;
  double height;

  std::cout <<
    "Enter your full name, age, and height: ";
  std::getline(std::cin, fullName, ','); //<h>
  std::cin >> age >> height;

  std::cout << "Full Name: " << fullName <<
    "\n";
  std::cout << "Age: " << age << "\n";
  std::cout << "Height: " << height <<
    " meters\n";
}
```


Here, we use `std::getline()` to read the full name up to a comma, then use `std::cin` for the remaining values. The user would input something like "John Doe, 25 1.75".


```plain text
//<o>
Enter your full name, age, and height: John Doe, 25 1.75
Full Name: John Doe
Age: 25
Height: 1.75 meters
```


## Using a String Stream


For more complex input parsing, we can use a string stream:


```c++
#include <iostream>
#include <string>
#include <sstream>

int main(){
  std::string input;
  std::string name;
  int age;
  double height;

  std::cout <<
    "Enter name, age, and height (separated by "
    "commas): ";
  std::getline(std::cin, input);

  std::istringstream iss(input); //<h>
  std::getline(iss, name, ',');
  iss >> age;
  iss.ignore(); // Ignore the comma
  iss >> height;

  std::cout << "Name: " << name << "\n";
  std::cout << "Age: " << age << "\n";
  std::cout << "Height: " << height <<
    " meters\n";
}
```


```plain text
//<o>
Enter name, age, and height (separated by commas): John,25,1.75
Name: John
Age: 25
Height: 1.75 meters
```


This approach gives you more control over how the input is split and parsed. It's particularly useful when dealing with more complex input formats or when you need to do additional validation.


Remember, when working with multiple inputs, always consider potential input errors and implement appropriate error handling to make your program robust.

Multiple Inputs on a Single Line in C++

Handling spaces in user input can be tricky when using `std::cin`, as it typically uses whitespace (including spaces) as delimiters.


However, there are several ways to effectively manage input with spaces. Let's explore some common approaches:


## Using `std::getline()`


The most straightforward way to handle input with spaces is to use `std::getline()`. This function reads an entire line of input, including spaces:


```c++
#include <iostream>
#include <string>

int main(){
  std::string fullName;

  std::cout << "Enter your full name: ";
  std::getline(std::cin, fullName); //<h>

  std::cout << "Hello, " << fullName << "!";
}
```


```plain text
//<o>
Enter your full name: John Doe
Hello, John Doe!
```


This approach works well when you want to capture an entire line of input, regardless of spaces.


## Mixing `std::cin` and `std::getline()`


Sometimes you might need to use both `std::cin` and `std::getline()` in your program. Be cautious, as this can lead to unexpected behavior:


```c++
#include <iostream>
#include <string>

int main(){
  int age;
  std::string name;

  std::cout << "Enter your age: ";
  std::cin >> age;

  std::cout << "Enter your full name: ";

  // Clear the newline left in the buffer
  std::cin.ignore();
  std::getline(std::cin, name); //<h>

  std::cout << "Name: " << name << ", Age: " <<
    age;
}
```


```plain text
//<o>
Enter your age: 25
Enter your full name: John Doe
Name: John Doe, Age: 25
```


Note the `std::cin.ignore()` call. This is necessary because `std::cin >>` leaves the newline character in the input buffer, which `std::getline()` would otherwise read as an empty line.


## Using Custom Delimiters


You can also use `std::getline()` with a custom delimiter to read input until a specific character is encountered:


```c++
#include <iostream>
#include <string>

int main(){
  std::string firstName, lastName;

  std::cout <<
    "Enter your first and last name (separated "
    "by a comma): ";
  std::getline(std::cin, firstName, ','); //<h>

  // Read the rest after the comma
  std::cin >> lastName;

  std::cout << "First Name: "
    << firstName << "\n";
  std::cout << "Last Name: "
    << lastName << "\n";
}
```


```plain text
//<o>
Enter your first and last name (separated by a comma): John,Doe
First Name: John
Last Name: Doe
```


This approach is useful when you have a known separator between parts of your input.


## Using a String Stream


For more complex parsing, you can combine `std::getline()` with a string stream:


```c++
#include <iostream>
#include <string>
#include <sstream>

int main(){
  std::string input, name, city;
  int age;

  std::cout <<
    "Enter name, age, and city (separated by "
    "commas): ";
  std::getline(std::cin, input);

  std::istringstream iss(input); //<h>
  std::getline(iss, name, ',');
  iss >> age;
  iss.ignore(); // Ignore the comma after age
  std::getline(iss, city);

  std::cout << "Name: " << name << "\n";
  std::cout << "Age: " << age << "\n";
  std::cout << "City: " << city << "\n";
}
```


```plain text
//<o>
Enter name, age, and city (separated by commas): John Doe,25,London
Name: John Doe
Age: 25
City: London
```


This method gives you fine-grained control over parsing complex input strings with multiple fields and potential spaces.


Remember, when handling user input, always consider potential errors and edge cases. Implement appropriate error checking and validation to ensure your program behaves correctly with various types of input.

Handling Spaces in User Input

Understanding the differences between `std::cin >>` and `std::getline()` is crucial for effective input handling in C++. Let's break down the key differences and use cases for each:


## `std::cin >>`


The `std::cin >>` operator is used for formatted input. It reads input until it encounters whitespace (space, tab, or newline).  Key characteristics include:

- Reads input word by word (separated by whitespace)
- Leaves the newline character in the input buffer
- Can be used with various data types (int, double, string, etc.)
- Stops reading at the first whitespace character

Here's an example:


```c++
#include <iostream>
#include <string>

int main(){
  int age;
  std::string name;

  std::cout << "Enter your age and name: ";
  std::cin >> age >> name; //<h>

  std::cout << "Age: " << age << ", Name: " <<
    name;
}
```


```plain text
//<o>
Enter your age and name: 25 John Doe
Age: 25, Name: John
```


Notice that only "John" is stored in `name`, as `std::cin >>` stops at the first space.


## `std::getline()`


`std::getline()` is used for reading entire lines of text, including spaces.  The key characteristics are:

- Reads input until it encounters a newline character (by default)
- Removes the newline character from the input buffer
- Primarily used with strings
- Can use custom delimiters

Here's an example:


```c++
#include <iostream>
#include <string>

int main(){
  std::string fullName;

  std::cout << "Enter your full name: ";
  std::getline(std::cin, fullName); //<h>

  std::cout << "Full Name: " << fullName;
}
```


```plain text
//<o>
Enter your full name: John Doe
Full Name: John Doe
```


## Key Differences

1. **Whitespace Handling**: `std::cin >>` treats whitespace as a delimiter, while `std::getline()` includes whitespace in the input.
2. **Newline Character**: `std::cin >>` leaves the newline character in the buffer, while `std::getline()` removes it.
3. **Flexibility**: `std::getline()` can use custom delimiters, offering more flexibility in input parsing.
4. **Data Types**: `std::cin >>` works with various data types, while `std::getline()` is primarily used with strings.
5. **Buffer Behavior**: After using `std::cin >>`, you often need to clear the input buffer before using `std::getline()`.

## Combining `std::cin` and `std::getline()`


When using both in the same program, be cautious:


```c++
#include <iostream>
#include <string>

int main(){
  int age;
  std::string name;

  std::cout << "Enter your age: ";
  std::cin >> age;

  // Clear the newline from the buffer
  std::cin.ignore(); //<h>

  std::cout << "Enter your full name: ";
  std::getline(std::cin, name);

  std::cout << "Age: " << age << ", Name: " <<
    name;
}
```


```plain text
//<o>
Enter your age: 25
Enter your full name: John Doe
Age: 25, Name: John Doe
```


The `std::cin.ignore()` call is crucial here to clear the newline left by `std::cin >>` before using `std::getline()`.


In summary, choose `std::cin >>` for simple, space-separated inputs of various types, and `std::getline()` for reading whole lines or when you need to include spaces in your input.


Be aware of their different behaviors, especially when using them together in your programs.

`std::cin` vs `std::getline()` in C++

<Excerpt>


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.


</Excerpt>


## 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.  Both `std::cout` and `std::cin` are available within the `<iostream>` header:


```c++
#include <iostream>
```


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 the `<string>` header 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:


```c++
#include <iostream>
#include <string>

int main() {
  std::string UserInput;

  std::cout << "Enter some text: ";
  std::getline(std::cin, UserInput);//<h>
  std::cout << "You entered: " << UserInput;
}
```


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:


```c++
//<o>
Enter some text: Hello!
You entered: Hello!
```


<Ad />


## 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:


```c++
#include <iostream>
#include <string>

class Character {
public:
  Character(const std::string& ClassName)
	: ClassName { ClassName } {
  }
  void SetName(const std::string& NewName) {
	Name = NewName;
  }
  std::string Name;
  std::string ClassName;
};

class Warrior : public Character {
public:
  Warrior() : Character("Warrior") {}
};

class Rogue : public Character {
public:
  Rogue() : Character("Rogue") {}
};

class Wizard : public Character {
public:
  Wizard() : Character("Wizard") {}
};

std::string SelectClass() {
  std::cout << "What class do you want to play?"
    << "\n- Enter 1 for Warrior"
    << "\n- Enter 2 for Rogue"
    << "\n- Enter 3 for Wizard"
    << "\n\nMake your selection: ";

  std::string ClassString;
  std::getline(std::cin, ClassString);//<h>
  return ClassString;
}

std::string SelectName() {
  std::cout << "Enter your name: ";

  std::string Name;
  std::getline(std::cin, Name);//<h>
  return Name;
}

int main() {
  Character* PlayerCharacter;
  Warrior PlayerWarrior;
  Rogue PlayerRogue;
  Wizard PlayerWizard;

  std::string SelectedClass{SelectClass()};
  if (SelectedClass == "1") {
	  PlayerCharacter = &PlayerWarrior;
  } else if (SelectedClass == "2") {
	  PlayerCharacter = &PlayerRogue;
  } else {
	  PlayerCharacter = &PlayerWizard;
  }

  PlayerCharacter->SetName(SelectName());

  std::cout
    << PlayerCharacter->Name << " the "
    << PlayerCharacter->ClassName
    << " is entering the arena!";
}
```


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


```c++
//<o>
What class do you want to play?
- Enter 1 for Warrior
- Enter 2 for Rogue
- Enter 3 for Wizard

Make your selection: 2
Enter your name: Grifter
Grifter 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()`. These techniques let us make our terminal programs interactive and responsive to user commands.


<Preview>


### Bitwise Operators


In the upcoming lesson, we'll introduce 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.

</Preview>

Abstract art representing computer programming

std::cin, std::wcin

std::getline

Standard library header <iostream>

Basic Input/Output - cplusplus.com

{CPP}Step-by-step guide to handling user input in C++ using std::cin and std::getline.

User Input in the Terminal

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers