28.2 — Input with istream

In this lesson, you'll learn how to effectively use C++ input streams, particularly std::cin, to read data from users and handle various input scenarios. You'll discover different input methods and how to handle input errors gracefully.

Understanding std::cin

std::cin (character input) is the standard input stream object that typically reads from the keyboard. It's an instance of the std::istream class and uses the extraction operator (>>) to read data.

#include <iostream>

int main()
{
    int number;
    
    std::cout << "Enter a number: ";
    std::cin >> number;  // Read integer from input
    
    std::cout << "You entered: " << number << std::endl;
    
    return 0;
}

Example Run:

Enter a number: 42
You entered: 42

The extraction operator (>>)

The extraction operator (>>) automatically:

• Skips whitespace (spaces, tabs, newlines)
• Converts input to the appropriate data type
• Stops reading when it encounters whitespace or incompatible characters

#include <iostream>
#include <string>

int main()
{
    int age;
    double salary;
    std::string name;
    
    std::cout << "Enter your age, salary, and name: ";
    std::cin >> age >> salary >> name;  // Chain multiple inputs
    
    std::cout << "Name: " << name << std::endl;
    std::cout << "Age: " << age << std::endl;
    std::cout << "Salary: $" << salary << std::endl;
    
    return 0;
}

Example Run:

Enter your age, salary, and name: 28 50000.50 John
Name: John
Age: 28
Salary: $50000.5

Reading different data types

Different data types behave differently with the extraction operator:

#include <iostream>
#include <string>

int main()
{
    // Reading basic types
    int intValue;
    double doubleValue;
    char charValue;
    bool boolValue;
    std::string stringValue;
    
    std::cout << "Enter an integer: ";
    std::cin >> intValue;
    
    std::cout << "Enter a decimal number: ";
    std::cin >> doubleValue;
    
    std::cout << "Enter a single character: ";
    std::cin >> charValue;
    
    std::cout << "Enter true/false (1/0): ";
    std::cin >> boolValue;
    
    std::cout << "Enter a word: ";
    std::cin >> stringValue;  // Stops at whitespace
    
    std::cout << "\nYou entered:" << std::endl;
    std::cout << "Integer: " << intValue << std::endl;
    std::cout << "Double: " << doubleValue << std::endl;
    std::cout << "Character: " << charValue << std::endl;
    std::cout << "Boolean: " << boolValue << std::endl;
    std::cout << "String: " << stringValue << std::endl;
    
    return 0;
}

Example Run:

Enter an integer: 42
Enter a decimal number: 3.14159
Enter a single character: X
Enter true/false (1/0): 1
Enter a word: Hello

You entered:
Integer: 42
Double: 3.14159
Character: X
Boolean: 1
String: Hello

Reading lines with getline()

When you need to read entire lines (including spaces), use std::getline():

#include <iostream>
#include <string>

int main()
{
    std::string firstName, fullName;
    
    std::cout << "Enter your first name: ";
    std::cin >> firstName;  // Reads one word
    
    // Clear the input buffer
    std::cin.ignore();
    
    std::cout << "Enter your full name: ";
    std::getline(std::cin, fullName);  // Reads entire line
    
    std::cout << "First name: " << firstName << std::endl;
    std::cout << "Full name: " << fullName << std::endl;
    
    return 0;
}

Example Run:

Enter your first name: John
Enter your full name: John Smith Jr.
First name: John
Full name: John Smith Jr.

Input buffer management

Understanding the input buffer is crucial for proper input handling:

#include <iostream>
#include <string>

int main()
{
    int number;
    std::string line;
    
    std::cout << "Enter a number: ";
    std::cin >> number;
    
    // The newline character is still in the buffer
    std::cout << "Enter a line of text: ";
    std::getline(std::cin, line);  // This might read the leftover newline!
    
    std::cout << "Number: " << number << std::endl;
    std::cout << "Line: '" << line << "'" << std::endl;
    
    return 0;
}

Problem Run:

Enter a number: 42
Enter a line of text: Number: 42
Line: ''

Solution: Use ignore() to clear the buffer

#include <iostream>
#include <string>

int main()
{
    int number;
    std::string line;
    
    std::cout << "Enter a number: ";
    std::cin >> number;
    
    // Clear any remaining characters in the buffer
    std::cin.ignore(1000, '\n');  // Ignore up to 1000 chars or until newline
    
    std::cout << "Enter a line of text: ";
    std::getline(std::cin, line);
    
    std::cout << "Number: " << number << std::endl;
    std::cout << "Line: '" << line << "'" << std::endl;
    
    return 0;
}

Fixed Run:

Enter a number: 42
Enter a line of text: Hello World
Number: 42
Line: 'Hello World'

Reading characters with get()

For more control over character input, use get():

#include <iostream>

int main()
{
    char ch;
    
    std::cout << "Enter some characters (press Enter to stop): ";
    
    while ((ch = std::cin.get()) != '\n')
    {
        std::cout << "You typed: '" << ch << "' (ASCII: " << static_cast<int>(ch) << ")" << std::endl;
    }
    
    std::cout << "Done reading characters." << std::endl;
    
    return 0;
}

Example Run:

Enter some characters (press Enter to stop): ABC
You typed: 'A' (ASCII: 65)
You typed: 'B' (ASCII: 66)
You typed: 'C' (ASCII: 67)
Done reading characters.

Input validation and error handling

Always check if input operations succeed:

#include <iostream>
#include <limits>

int main()
{
    int number;
    
    while (true)
    {
        std::cout << "Enter an integer: ";
        
        if (std::cin >> number)
        {
            std::cout << "You entered: " << number << std::endl;
            break;  // Success, exit loop
        }
        else
        {
            std::cout << "Invalid input! Please enter an integer." << std::endl;
            
            // Clear error flags
            std::cin.clear();
            
            // Remove bad input from buffer
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
    }
    
    return 0;
}

Example Run:

Enter an integer: hello
Invalid input! Please enter an integer.
Enter an integer: 3.14
Invalid input! Please enter an integer.
Enter an integer: 42
You entered: 42

Reading formatted input

You can read multiple values with specific formatting:

#include <iostream>
#include <iomanip>

int main()
{
    int day, month, year;
    char separator1, separator2;
    
    std::cout << "Enter date (DD/MM/YYYY): ";
    std::cin >> day >> separator1 >> month >> separator2 >> year;
    
    if (separator1 == '/' && separator2 == '/')
    {
        std::cout << "Date entered: " << day << "/" << month << "/" << year << std::endl;
    }
    else
    {
        std::cout << "Invalid date format!" << std::endl;
    }
    
    return 0;
}

Example Run:

Enter date (DD/MM/YYYY): 15/03/2024
Date entered: 15/3/2024

Reading until end of input

Sometimes you need to read all available input:

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> numbers;
    int number;
    
    std::cout << "Enter numbers (Ctrl+D or Ctrl+Z when done):" << std::endl;
    
    while (std::cin >> number)
    {
        numbers.push_back(number);
    }
    
    std::cout << "Numbers entered: ";
    for (int num : numbers)
    {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Example Run:

Enter numbers (Ctrl+D or Ctrl+Z when done):
10 20 30 40 50
Numbers entered: 10 20 30 40 50

Common input patterns

Pattern 1: Safe integer input

#include <iostream>
#include <limits>

int getInteger(const std::string& prompt)
{
    int value;
    while (true)
    {
        std::cout << prompt;
        if (std::cin >> value)
        {
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            return value;
        }
        else
        {
            std::cout << "Invalid input. Please enter an integer." << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
    }
}

int main()
{
    int age = getInteger("Enter your age: ");
    std::cout << "You are " << age << " years old." << std::endl;
    
    return 0;
}

Pattern 2: Menu selection

#include <iostream>

int main()
{
    int choice;
    
    do
    {
        std::cout << "\nMenu:\n";
        std::cout << "1. Option A\n";
        std::cout << "2. Option B\n";
        std::cout << "3. Option C\n";
        std::cout << "0. Exit\n";
        std::cout << "Enter your choice: ";
        
        std::cin >> choice;
        
        switch (choice)
        {
            case 1:
                std::cout << "You selected Option A" << std::endl;
                break;
            case 2:
                std::cout << "You selected Option B" << std::endl;
                break;
            case 3:
                std::cout << "You selected Option C" << std::endl;
                break;
            case 0:
                std::cout << "Goodbye!" << std::endl;
                break;
            default:
                std::cout << "Invalid choice!" << std::endl;
        }
    }
    while (choice != 0);
    
    return 0;
}

Best practices for input handling

✅ Good practices:

#include <iostream>
#include <limits>

int main()
{
    // Always provide clear prompts
    std::cout << "Please enter your age (1-120): ";
    
    int age;
    if (std::cin >> age)
    {
        // Validate input range
        if (age >= 1 && age <= 120)
        {
            std::cout << "Age: " << age << std::endl;
        }
        else
        {
            std::cout << "Age must be between 1 and 120!" << std::endl;
        }
        
        // Clear buffer after successful read
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    else
    {
        std::cout << "Invalid input format!" << std::endl;
    }
    
    return 0;
}

❌ Common mistakes:

#include <iostream>

int main()
{
    // Bad: No prompt
    int age;
    std::cin >> age;
    
    // Bad: No error checking
    std::cout << "Age: " << age << std::endl;  // Could be garbage
    
    // Bad: Mixing >> and getline without buffer management
    std::string name;
    std::getline(std::cin, name);  // Might read leftover newline
    
    return 0;
}

Summary

Effective input handling with std::istream requires understanding:

• Extraction operator (>>) automatically skips whitespace and converts types
• getline() reads entire lines including spaces
• Buffer management with ignore() prevents input mixing issues
• Error checking ensures input operations succeed
• Input validation verifies data is within expected ranges
• Character input with get() provides fine-grained control

Proper input handling makes your programs more robust and user-friendly. Always validate input and provide clear error messages to guide users.

Quiz

1. What does the extraction operator (>>) automatically do with whitespace?
2. When should you use std::getline() instead of the extraction operator?
3. Why is std::cin.ignore() important when mixing >> and getline()?
4. How can you check if an input operation was successful?
5. What's the difference between std::cin.get() and std::cin >> char_variable?

Practice exercises

Try these exercises to master input handling:

1. User Profile: Create a program that reads a user's first name, last name, age, and email address, handling spaces in names properly.

2. Robust Calculator: Build a calculator that keeps asking for input until the user enters valid numbers and operators, with proper error messages.

3. Text Analyzer: Write a program that reads lines of text until the user enters "quit" and reports the total number of lines and characters.

4. Grade Entry: Create a program that reads student grades, validates they're between 0-100, and calculates the average grade.