Coming Soon

Input and output (I/O) streams

In this lesson, you'll learn about the foundation of C++ input and output: the stream system. You'll understand what streams are, how they work, and why they're essential for communicating with users and external data sources.

What are I/O streams?

A stream is a sequence of data that can be read from or written to. Think of a stream like a pipeline or conveyor belt that moves data from one place to another.

In C++, streams provide a uniform way to handle input and output operations, whether you're:

• Reading from the keyboard
• Writing to the screen
• Reading from a file
• Writing to a file
• Working with strings in memory

The iostream library

The <iostream> library is the heart of C++ I/O operations. It provides several important stream objects:

#include <iostream>

int main()
{
    std::cout << "Hello, world!" << std::endl;  // Output stream
    
    int number;
    std::cin >> number;  // Input stream
    
    std::cout << "You entered: " << number << std::endl;
    
    return 0;
}

Example Output:

Hello, world!
42
You entered: 42

The stream hierarchy

C++ streams are organized in a hierarchy of classes:

Base classes:

• std::ios - Base class for all stream classes
• std::istream - Base class for input streams
• std::ostream - Base class for output streams
• std::iostream - Base class for bidirectional streams

Standard stream objects:

• std::cin - Standard input stream (usually keyboard)
• std::cout - Standard output stream (usually screen)
• std::cerr - Standard error stream (unbuffered)
• std::clog - Standard log stream (buffered)

Understanding stream operations

Output streams (ostream)

Output streams use the insertion operator (<<) to send data:

#include <iostream>

int main()
{
    int age = 25;
    double height = 5.9;
    std::string name = "Alice";
    
    std::cout << "Name: " << name << std::endl;
    std::cout << "Age: " << age << " years" << std::endl;
    std::cout << "Height: " << height << " feet" << std::endl;
    
    return 0;
}

Output:

Name: Alice
Age: 25 years
Height: 5.9 feet

Input streams (istream)

Input streams use the extraction operator (>>) to read data:

#include <iostream>
#include <string>

int main()
{
    std::string firstName, lastName;
    int age;
    
    std::cout << "Enter your first name: ";
    std::cin >> firstName;
    
    std::cout << "Enter your last name: ";
    std::cin >> lastName;
    
    std::cout << "Enter your age: ";
    std::cin >> age;
    
    std::cout << "Hello, " << firstName << " " << lastName << "!" << std::endl;
    std::cout << "You are " << age << " years old." << std::endl;
    
    return 0;
}

Example Run:

Enter your first name: John
Enter your last name: Smith
Enter your age: 30
Hello, John Smith!
You are 30 years old.

Stream chaining

One of the powerful features of streams is that you can chain operations:

#include <iostream>

int main()
{
    int a = 10, b = 20, c = 30;
    
    // Chained output
    std::cout << "Values: " << a << ", " << b << ", " << c << std::endl;
    
    // Chained input
    std::cout << "Enter three numbers: ";
    std::cin >> a >> b >> c;
    
    std::cout << "Sum: " << (a + b + c) << std::endl;
    
    return 0;
}

Example Run:

Values: 10, 20, 30
Enter three numbers: 5 15 25
Sum: 45

Standard error and log streams

Besides std::cout, C++ provides two other output streams:

#include <iostream>

int main()
{
    std::cout << "This is normal output" << std::endl;
    std::cerr << "This is an error message" << std::endl;
    std::clog << "This is a log message" << std::endl;
    
    return 0;
}

Output:

This is normal output
This is an error message
This is a log message

Key differences:

• std::cout - Buffered output (may be delayed)
• std::cerr - Unbuffered error output (immediate)
• std::clog - Buffered error/log output

Stream formatting basics

Streams automatically format different data types:

#include <iostream>

int main()
{
    int integer = 42;
    double decimal = 3.14159;
    bool boolean = true;
    char character = 'X';
    
    std::cout << "Integer: " << integer << std::endl;
    std::cout << "Decimal: " << decimal << std::endl;
    std::cout << "Boolean: " << boolean << std::endl;
    std::cout << "Character: " << character << std::endl;
    
    return 0;
}

Output:

Integer: 42
Decimal: 3.14159
Boolean: 1
Character: X

Working with endl vs '\n'

There are two common ways to create new lines:

#include <iostream>

int main()
{
    std::cout << "Line 1" << std::endl;  // Flushes the buffer
    std::cout << "Line 2\n";            // Just adds newline
    std::cout << "Line 3" << std::endl;
    
    return 0;
}

Output:

Line 1
Line 2
Line 3

Key difference:

• std::endl adds a newline AND flushes the output buffer
• '\n' only adds a newline (more efficient for multiple outputs)

Stream states

Streams maintain internal state information that you can check:

#include <iostream>

int main()
{
    int number;
    
    std::cout << "Enter a number: ";
    std::cin >> number;
    
    if (std::cin.good())
    {
        std::cout << "Successfully read: " << number << std::endl;
    }
    else
    {
        std::cout << "Failed to read input!" << std::endl;
    }
    
    return 0;
}

Example Run 1:

Enter a number: 42
Successfully read: 42

Example Run 2:

Enter a number: hello
Failed to read input!

Best practices for stream I/O

✅ Good practices:

#include <iostream>
#include <string>

int main()
{
    // Use meaningful prompts
    std::cout << "Please enter your age: ";
    
    // Check input success
    int age;
    if (std::cin >> age)
    {
        std::cout << "Age entered: " << age << std::endl;
    }
    else
    {
        std::cerr << "Invalid age entered!" << std::endl;
    }
    
    return 0;
}

❌ Common mistakes:

#include <iostream>

int main()
{
    // Bad: No prompt for user
    int number;
    std::cin >> number;
    
    // Bad: Not checking if input succeeded
    std::cout << "Number: " << number << std::endl;  // May be garbage!
    
    return 0;
}

Understanding buffering

Streams use buffers to improve performance:

#include <iostream>

int main()
{
    std::cout << "This might not appear immediately...";
    
    // Force the buffer to flush
    std::cout.flush();
    
    // Or use endl which flushes automatically
    std::cout << "This appears right away!" << std::endl;
    
    return 0;
}

Summary

The C++ stream system provides a unified way to handle input and output:

• Streams are sequences of data that can be read from or written to
• iostream library provides the foundation with cin, cout, cerr, and clog
• Stream operators (<< for output, >> for input) make I/O operations intuitive
• Stream chaining allows multiple operations in one statement
• Stream states help you detect and handle I/O errors
• Buffering improves performance but can affect timing of output

Understanding streams is crucial for effective C++ programming, as they form the basis for all input/output operations, from simple console programs to complex file handling.

Quiz

1. What is the difference between std::cout, std::cerr, and std::clog?
2. What does the << operator do in the context of streams?
3. How is std::endl different from '\n'?
4. What happens when you chain multiple input or output operations?
5. Why should you check the state of a stream after input operations?

Practice exercises

Try these exercises to reinforce your understanding:

1. Basic I/O: Write a program that asks for the user's name, age, and favorite color, then displays a formatted summary.

2. Calculator: Create a simple calculator that reads two numbers and an operator (+, -, *, /) and displays the result.

3. Data validation: Write a program that keeps asking for a number until the user enters a valid integer.

4. Stream comparison: Write a program that demonstrates the difference between std::cout, std::cerr, and std::clog by writing different messages to each.