Input and Output with `cin` and `cout`

1. The Concept of I/O Streams

At a high level, C++ handles input and output (I/O) using a concept called streams. Think of a stream as a flowing channel of characters. An input stream flows from an input device (like your keyboard) into your program. An output stream flows from your program to an output device (like your console window).

This diagram illustrates how a C++ program uses an input stream to receive data from a source (like the keyboard) and an output stream to send data to a sink (like the console).

To use these streams, we must first include the iostream library at the top of our code. This library provides us with the essential tools we need, primarily std::cin for input and std::cout for output.

Let's watch a short video that introduces these core concepts.

2. Displaying Formatted Output with std::cout

You've already used std::cout to print results. Now, let's formalize its use and learn how to create more complex, formatted output.

The << operator, known as the insertion operator, is used to "insert" data into the output stream. You can chain this operator to combine string literals (text in quotes) and variables in a single line.

#include <iostream>

int main() {
    int score = 95;
    std::cout << "Your final score is: " << score << ". Congratulations!";
    // Output: Your final score is: 95. Congratulations!
    return 0;
}

Newlines: '\n' vs. std::endl

When you want to move the cursor to the next line, you have two common options: '\n' and std::endl. While they seem to do the same thing, there's a key difference that is important for writing efficient code.

To understand this difference and master cout, let's read a section from a highly-regarded C++ tutorial.

From now on, we will follow the best practice of using '\n' for newlines in our output.

3. Reading User Input with std::cin

Now for the exciting part: getting input from the user. We use the std::cin object along with the >> operator, known as the extraction operator. It "extracts" data from the input stream (the keyboard) and stores it in a variable.

Let's see this in action by watching a complete program being built, which brings cin, cout, and the operators from our last lesson together.

As you saw, you can chain the extraction operator to read multiple values:

#include <iostream>

int main() {
    int num1, num2;
    std::cout << "Enter two numbers separated by a space: ";
    std::cin >> num1 >> num2; // Reads the first number into num1, the second into num2
    std::cout << "You entered " << num1 << " and " << num2 << '\n';
    return 0;
}

4. How cin Really Works: Buffering and Extraction

To truly master cin, it's helpful to understand what happens behind the scenes. User input is buffered, meaning it's stored temporarily before your program uses it. This has important implications for how your program behaves.

For a deeper understanding, which is one of your key goals, we'll dive into the details of the cin buffer.

This knowledge of the input buffer is what separates a beginner from an intermediate programmer. It's essential for debugging tricky input-related problems later on.

5. Practice: Building an Interactive Program

Now it's time to put all this theory into practice. Your goal is to build strong problem-solving skills, and the best way to do that is by writing code.

Your Task:
Write a C++ program that calculates the area and perimeter of a rectangle.

1. Prompt the user to enter the length of the rectangle (as a double).
2. Read the length into a variable.
3. Prompt the user to enter the width of the rectangle (as a double).
4. Read the width into a variable.
5. Calculate the area (length * width).
6. Calculate the perimeter (2 * (length + width)).
7. Display the results in a nicely formatted message, for example: "A rectangle with length 5.5 and width 10.0 has an area of 55.0 and a perimeter of 31.0."

Try to write this program yourself from scratch in your code editor. Compile and run it to see if it works as expected.

#include <iostream>

int main() {
    // 1. Declare variables for length, width, area, and perimeter.
    double length, width, area, perimeter;

    // 2. Prompt for and read the length.
    std::cout << "Enter the length: ";
    std::cin >> length;

    // 3. Prompt for and read the width.
    // ... your code here ...

    // 4. Calculate area and perimeter.
    // ... your code here ...

    // 5. Display the results.
    // ... your code here ...

    return 0;
}

#include <iostream>

int main() {
    // Declare variables
    double length, width, area, perimeter;

    // Prompt for and read the length
    std::cout << "Enter the length of the rectangle: ";
    std::cin >> length;

    // Prompt for and read the width
    std::cout << "Enter the width of the rectangle: ";
    std::cin >> width;

    // Calculate the area and perimeter
    area = length * width;
    perimeter = 2 * (length + width);

    // Display the results
    std::cout << "A rectangle with length " << length << " and width " << width
              << " has an area of " << area << " and a perimeter of " << perimeter << ".\n";

    return 0;
}

Conclusion

Fantastic work! You have now unlocked the ability to make your programs interactive. This is a huge step forward and the foundation for almost every application you will build.

Key Takeaways:

• You must #include <iostream> to perform standard input and output.
• std::cout uses the insertion operator (<<) to send data to the console.
• std::cin uses the extraction operator (>>) to read data from the keyboard into variables.
• For newlines, '\n' is generally preferred over std::endl for better performance.
• Both << and >> operators can be chained to handle multiple items in a single statement.
• cin uses a buffer and has specific rules for extracting data and handling whitespace, which are important to understand for debugging.

In the next lesson, we will learn how to implement conditional logic using if, else if, and else statements. Now that your program can receive user input, the next logical step is to make decisions and perform different actions based on that input.