C++ Stream Operations

Every C++ stream maintains internal state flags that indicate whether operations have succeeded or failed. Understanding these states is crucial for writing robust code that handles errors gracefully and avoids silent failures.

Understanding Stream State Flags

Streams track their status using four boolean flags. When an operation fails, one or more of these flags are set, allowing you to detect and respond to problems. Learning to check these flags is essential for professional-quality C++ code.

Checking Stream States

#include <iostream>
#include <fstream>

int main() {
    std::ifstream file("data.txt");
    
    // Method 1: Boolean conversion
    if (!file) {
        std::cerr << "Failed to open file!" << std::endl;
        return 1;
    }

    // Method 2: Explicit state check
    if (file.good()) {
        std::cout << "File is ready for reading" << std::endl;
    }

    int number;
    file >> number;
    
    // Check if read succeeded
    if (file.fail()) {
        std::cerr << "Failed to read integer!" << std::endl;
    }

    // Check for end of file
    if (file.eof()) {
        std::cout << "Reached end of file" << std::endl;
    }
    
    return 0;
}

Clearing Stream Errors

When a stream enters a failed state, it stays that way until you explicitly clear the error flags. This is essential for recovery scenarios where you want to try again after an error.

#include <iostream>
#include <sstream>
#include <limits>

int main() {
    std::istringstream iss("abc 123");
    
    int num;
    iss >> num;  // Fails - "abc" is not a number

    if (iss.fail()) {
        std::cout << "Read failed, clearing error..." << std::endl;
        
        // Clear the error flags
        iss.clear();

        // Skip the bad input
        std::string garbage;
        iss >> garbage;  // Reads "abc"

        // Try again
        iss >> num;  // Now reads 123
        
        if (iss.good()) {
            std::cout << "Successfully read: " << num << std::endl;
        }
    }
    
    return 0;
}

Safe Input with Error Recovery

#include <iostream>
#include <limits>

int getValidInteger(const std::string& prompt) {
    int value;
    
    while (true) {
        std::cout << prompt;
        std::cin >> value;

        if (std::cin.good()) {
            return value;  // Success!
        }

        // Handle error
        std::cout << "Invalid input! Please enter a number." << std::endl;
        
        // Clear error flags
        std::cin.clear();

        // Discard bad input (up to newline)
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
}

int main() {
    int age = getValidInteger("Enter your age: ");
    std::cout << "Your age is: " << age << std::endl;
    return 0;
}

std::string filename = "test.txt";

#include <fstream>
#include <iostream>

int main() {
    std::ifstream file("test.txt");
    
    if (file.is_open() && file.good()) {
        std::cout << "File opened successfully!" << std::endl;
        file.close();
    } else {
        std::cerr << "Failed to open file." << std::endl;
        if (file.bad()) {
            std::cerr << "Critical I/O error!" << std::endl;
        }
    }
    
    return 0;
}

std::string inputs[] = {"3.14159", "abc", "12.5abc"};

Parsed: 3.14159
Failed to parse 'abc'
Failed to parse '12.5abc' (trailing chars)

#include <sstream>
#include <iostream>
#include <string>

bool parseDouble(const std::string& str, double& result) {
    std::istringstream iss(str);
    iss >> result;
    
    // Check if we read something and reached end of string
    return !iss.fail() && iss.eof();
}

int main() {
    double value;
    
    if (parseDouble("3.14159", value)) {
        std::cout << "Parsed: " << value << std::endl;
    }
    
    if (!parseDouble("abc", value)) {
        std::cout << "Failed to parse 'abc'" << std::endl;
    }
    
    if (!parseDouble("12.5abc", value)) {
        std::cout << "Failed to parse '12.5abc' (trailing chars)" << std::endl;
    }
    
    return 0;
}

int minValue = 1;
int maxValue = 100;

Enter a number between 1 and 100: abc
Error: Invalid input. Please enter a number.
Enter a number between 1 and 100: 150
Error: Number out of range. Must be 1-100.
Enter a number between 1 and 100: 50
Valid input received: 50

#include <iostream>
#include <limits>

int main() {
    int number;
    bool validInput = false;
    
    while (!validInput) {
        std::cout << "Enter a number between 1 and 100: ";
        std::cin >> number;
        
        if (std::cin.fail()) {
            // Clear error state
            std::cin.clear();
            // Discard bad input
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cout << "Error: Invalid input. Please enter a number.\n" << std::endl;
        } else if (number < 1 || number > 100) {
            std::cout << "Error: Number out of range. Must be 1-100.\n" << std::endl;
        } else {
            validInput = true;
            std::cout << "Valid input received: " << number << std::endl;
        }
    }
    
    return 0;
}

// File: numbers.txt contains:
// 10 20 30 invalid 50

Error: Invalid data format in file (non-numeric content)
Successfully read 3 numbers before error

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ifstream file("numbers.txt");
    
    // Check if file opened successfully
    if (!file.is_open()) {
        std::cerr << "Error: Could not open file 'numbers.txt'" << std::endl;
        return 1;
    }
    
    int number, sum = 0, count = 0;
    bool errorOccurred = false;
    
    while (file >> number) {
        sum += number;
        count++;
        
        // Check for critical I/O errors after read
        if (file.bad()) {
            std::cerr << "Error: Critical I/O error while reading file" << std::endl;
            errorOccurred = true;
            break;
        }
    }
    
    // Check why loop ended
    if (!errorOccurred) {
        if (file.eof()) {
            // Normal end - all data read successfully
            std::cout << "Successfully read " << count << " numbers" << std::endl;
            std::cout << "Sum: " << sum << std::endl;
        } else if (file.fail()) {
            // Format error - non-numeric data encountered
            std::cerr << "Error: Invalid data format in file (non-numeric content)" << std::endl;
            std::cerr << "Successfully read " << count << " numbers before error" << std::endl;
            errorOccurred = true;
        }
    }
    
    file.close();
    return errorOccurred ? 1 : 0;
}

Professional applications require polished, well-formatted output. C++ provides powerful formatting tools through the <iomanip> header that let you control precision, alignment, padding, and number representation.

The iomanip Header

The <iomanip> header provides manipulators - special functions that modify how streams format output. Unlike regular functions, manipulators are inserted directly into the stream using <<.

Controlling Field Width with setw

The setw() manipulator sets the minimum field width for the very next output item. If the content is shorter than the specified width, it's padded with the fill character (space by default). If it's longer, the content is printed in full without truncation. This is the primary tool for creating aligned columns in text-based tables and reports. Unlike most manipulators, setw() is not sticky - it only affects one output operation.

#include <iostream>
#include <iomanip>

int main() {
    // setw only affects the NEXT output item
    std::cout << std::setw(10) << "Name" << std::setw(8) << "Age" << std::setw(10) << "Salary" << std::endl;

    std::cout << std::setw(10) << "Alice" << std::setw(8) << 28 << std::setw(10) << 75000 << std::endl;
    std::cout << std::setw(10) << "Bob" << std::setw(8) << 34 << std::setw(10) << 82000 << std::endl;
    std::cout << std::setw(10) << "Charlie" << std::setw(8) << 22 << std::setw(10) << 55000 << std::endl;

    return 0;
}

Formatting Numbers with setprecision

The setprecision() manipulator controls how many digits are displayed for floating-point numbers. Its behavior changes dramatically depending on whether you use it with fixed or scientific flags. Without any flags, it controls significant digits (total meaningful digits). With fixed, it controls decimal places (digits after the decimal point). Understanding this distinction is crucial for proper number formatting.

#include <iostream>
#include <iomanip>
#include <cmath>

int main() {
    double pi = 3.14159265358979;
    
    // Default precision (usually 6 significant digits)
    std::cout << "Default: " << pi << std::endl;  // 3.14159

    // setprecision without fixed = significant digits
    std::cout << "3 sig digits: " << std::setprecision(3) << pi << std::endl;  // 3.14

    // fixed + setprecision = decimal places
    std::cout << std::fixed;
    std::cout << "2 decimal places: " << std::setprecision(2) << pi << std::endl;  // 3.14
    std::cout << "5 decimal places: " << std::setprecision(5) << pi << std::endl;  // 3.14159

    // Scientific notation
    std::cout << std::scientific;
    std::cout << "Scientific: " << std::setprecision(3) << pi << std::endl;  // 3.142e+00
    
    return 0;
}

Alignment and Fill Characters

When using setw() to create fixed-width fields, you can control where content appears within that field and what character fills the empty space. C++ provides alignment manipulators (left, right, internal) to position content, and setfill() to customize the padding character. These tools are essential for creating professional-looking tables, reports, and formatted output.

#include <iostream>
#include <iomanip>

int main() {
    // Right alignment (default)
    std::cout << "Right aligned:" << std::endl;
    std::cout << std::right << std::setw(10) << 42 << std::endl;      // "        42"

    // Left alignment
    std::cout << "Left aligned:" << std::endl;
    std::cout << std::left << std::setw(10) << 42 << "|" << std::endl; // "42        |"

    // Custom fill character
    std::cout << "With fill character:" << std::endl;
    std::cout << std::right << std::setfill('0') << std::setw(5) << 42 << std::endl;  // "00042"
    std::cout << std::setfill('.') << std::setw(10) << "Price" << std::endl;  // ".....Price"

    // Reset fill to space
    std::cout << std::setfill(' ');
    
    return 0;
}

Formatting Currency and Tables

Combining multiple formatting manipulators creates professional-looking tables and reports. For currency and financial data, you'll typically use fixed with setprecision(2) for exactly two decimal places, setw() for column alignment, and mix left/right alignment depending on content type. This real-world example demonstrates how all these techniques work together to produce polished, production-quality output.

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>

struct Product {
    std::string name;
    double price;
    int quantity;
};

int main() {
    std::vector<Product> inventory = {
        {"Laptop", 999.99, 15},
        {"Mouse", 29.50, 150},
        {"Keyboard", 79.99, 75},
        {"Monitor", 349.00, 30}
    };

    // Print table header
    std::cout << std::left << std::setw(15) << "Product"
              << std::right << std::setw(12) << "Price"
              << std::setw(10) << "Qty"
              << std::setw(15) << "Total" << std::endl;
    std::cout << std::string(52, '-') << std::endl;

    // Print each product
    double grandTotal = 0;
    for (const auto& p : inventory) {
        double total = p.price * p.quantity;
        grandTotal += total;
        
        std::cout << std::left << std::setw(15) << p.name
                  << std::right << "$" << std::fixed << std::setprecision(2)
                  << std::setw(10) << p.price
                  << std::setw(10) << p.quantity
                  << "$" << std::setw(13) << total << std::endl;
    }

    std::cout << std::string(52, '-') << std::endl;
    std::cout << std::left << std::setw(37) << "Grand Total:"
              << "$" << std::right << std::setw(13) << grandTotal << std::endl;
    
    return 0;
}

double price = 19.5;

#include <iostream>
#include <iomanip>

int main() {
    double price = 19.5;
    
    std::cout << "$" << std::fixed << std::setprecision(2) << price << std::endl;
    // Output: $19.50
    
    return 0;
}

int numbers[] = {5, 42, 389, 7, 1024};

     5
    42
   389
     7
  1024

#include <iostream>
#include <iomanip>

int main() {
    int numbers[] = {5, 42, 389, 7, 1024};
    
    for (int num : numbers) {
        std::cout << std::right << std::setw(6) << num << std::endl;
    }
    
    return 0;
}

int employeeId = 42;

#include <iostream>
#include <iomanip>

int main() {
    int employeeId = 42;
    
    std::cout << "EMP-" << std::setfill('0') << std::setw(5) << employeeId << std::endl;
    // Output: EMP-00042
    
    // Reset fill character for subsequent output
    std::cout << std::setfill(' ');
    
    return 0;
}

struct Product { std::string name; double price; int qty; };
Product products[] = {
    {"Apple", 1.50, 100},
    {"Banana", 0.75, 250},
    {"Orange Juice", 3.99, 45}
};

Product         |   Price|   Qty
--------------------------------
Apple           |   $1.50|   100
Banana          |   $0.75|   250
Orange Juice    |   $3.99|    45

#include <iostream>
#include <iomanip>
#include <string>

struct Product { std::string name; double price; int qty; };

int main() {
    Product products[] = {
        {"Apple", 1.50, 100},
        {"Banana", 0.75, 250},
        {"Orange Juice", 3.99, 45}
    };
    
    // Header
    std::cout << std::left << std::setw(15) << "Product" << "|" 
              << std::right << std::setw(7) << "Price" << "|" 
              << std::setw(6) << "Qty" << std::endl;
    std::cout << std::string(32, '-') << std::endl;
    
    // Data rows
    std::cout << std::fixed << std::setprecision(2);
    for (const auto& p : products) {
        std::cout << std::left << std::setw(15) << p.name << "|" 
                  << std::right << "$" << std::setw(6) << p.price << "|" 
                  << std::setw(6) << p.qty << std::endl;
    }
    
    return 0;
}

Stream manipulators modify how streams interpret and display data. Beyond the basic formatting manipulators, C++ provides specialized manipulators for different number bases, boolean representation, and more.

Number Base Manipulators

Sometimes you need to display numbers in different bases - hexadecimal for memory addresses, octal for file permissions, or binary for bit patterns. C++ makes this easy with base manipulators.

#include <iostream>
#include <iomanip>

int main() {
    int value = 255;
    
    std::cout << "Decimal:     " << std::dec << value << std::endl;  // 255
    std::cout << "Hexadecimal: " << std::hex << value << std::endl;  // ff
    std::cout << "Octal:       " << std::oct << value << std::endl;  // 377

    // With base prefix using showbase
    std::cout << std::showbase;
    std::cout << "Hex with prefix: " << std::hex << value << std::endl;  // 0xff
    std::cout << "Oct with prefix: " << std::oct << value << std::endl;  // 0377

    // Uppercase hex
    std::cout << std::uppercase;
    std::cout << "Uppercase hex: " << std::hex << value << std::endl;  // 0XFF

    // Reset to decimal
    std::cout << std::dec << std::noshowbase << std::nouppercase;
    
    return 0;
}

Boolean Representation

By default, C++ streams output boolean values as integers (1 for true, 0 for false). While compact, this numeric representation isn't always intuitive. The boolalpha manipulator switches to textual output ("true"/"false"), making your output more readable and self-documenting. This is especially valuable in logs, debugging output, and user-facing messages where clarity matters more than brevity.

#include <iostream>
#include <iomanip>

int main() {
    bool flag = true;
    
    // Default: prints 1 or 0
    std::cout << "Default: " << flag << std::endl;  // 1

    // With boolalpha: prints true or false
    std::cout << std::boolalpha;
    std::cout << "Boolalpha: " << flag << std::endl;  // true
    std::cout << "False: " << false << std::endl;     // false

    // Turn off boolalpha
    std::cout << std::noboolalpha;
    std::cout << "Back to numeric: " << flag << std::endl;  // 1
    
    return 0;
}

Positive Sign and Decimal Point

Fine-tune numeric output with showpos to display explicit plus signs for positive numbers, and showpoint to always show decimal points for floating-point values. The showpos manipulator is useful when sign information is meaningful (temperature changes, financial deltas, coordinates), while showpoint helps distinguish floating-point values from integers in scientific or technical output where type clarity is important.

#include <iostream>
#include <iomanip>

int main() {
    // Show positive sign
    std::cout << std::showpos;
    std::cout << 42 << " " << -42 << std::endl;  // +42 -42
    std::cout << std::noshowpos;

    // Always show decimal point
    std::cout << std::showpoint;
    std::cout << 100.0 << std::endl;  // 100.000 (shows decimal)
    std::cout << std::noshowpoint;
    std::cout << 100.0 << std::endl;  // 100 (no decimal if not needed)
    
    return 0;
}

Flushing Output

Stream output is normally buffered for efficiency - text accumulates in memory before being written to the destination. Flushing forces immediate output by emptying the buffer. Use endl to add a newline AND flush, or flush alone when you need immediate output without a newline. Flushing is essential for progress indicators, prompts, and critical messages, but overuse can impact performance since each flush is a system call.

#include <iostream>

int main() {
    // endl flushes the buffer AND adds newline
    std::cout << "Line 1" << std::endl;

    // flush only flushes, no newline
    std::cout << "Waiting..." << std::flush;

    // For debugging - output appears immediately
    for (int i = 0; i < 5; i++) {
        std::cout << "." << std::flush;
        // simulate work...
    }
    std::cout << " Done!" << std::endl;
    
    return 0;
}

int colorCode = 255;

#include <iostream>

int main() {
    int colorCode = 255;
    
    std::cout << std::hex << std::uppercase << std::showbase 
              << colorCode << std::endl;
    // Output: 0XFF
    
    // Reset to decimal
    std::cout << std::dec << std::nouppercase << std::noshowbase;
    
    return 0;
}

bool isActive = true;
bool isAdmin = false;

Active: true
Admin: false

#include <iostream>

int main() {
    bool isActive = true;
    bool isAdmin = false;
    
    std::cout << std::boolalpha;
    std::cout << "Active: " << isActive << std::endl;
    std::cout << "Admin: " << isAdmin << std::endl;
    
    // Reset to numeric display
    std::cout << std::noboolalpha;
    
    return 0;
}

int change1 = 50;
int change2 = -30;
int change3 = 0;

Change: +50
Change: -30
Change: +0

#include <iostream>

int main() {
    int change1 = 50;
    int change2 = -30;
    int change3 = 0;
    
    std::cout << std::showpos;
    std::cout << "Change: " << change1 << std::endl;
    std::cout << "Change: " << change2 << std::endl;
    std::cout << "Change: " << change3 << std::endl;
    
    std::cout << std::noshowpos;  // Reset
    
    return 0;
}

int values[] = {10, 20, 30};

[0x00C5F8A0] = 10
[0x00C5F8A4] = 20
[0x00C5F8A8] = 30

#include <iostream>
#include <iomanip>
#include <cstdint>

int main() {
    int values[] = {10, 20, 30};
    
    for (int i = 0; i < 3; i++) {
        uintptr_t addr = reinterpret_cast<uintptr_t>(&values[i]);
        
        std::cout << "[0x" 
                  << std::hex << std::uppercase 
                  << std::setfill('0') << std::setw(8) 
                  << addr 
                  << "] = " 
                  << std::dec << values[i] 
                  << std::endl;
    }
    
    // Reset manipulators
    std::cout << std::setfill(' ') << std::nouppercase;
    
    return 0;
}

One of C++'s most powerful features is the ability to define custom stream operators for your own types. This lets you seamlessly integrate your classes with the stream I/O system, making them as easy to print and read as built-in types.

Overloading the Output Operator

To make your class work with cout and other output streams, you overload the << operator. The convention is to make it a friend function that returns a reference to the stream.

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    Person(const std::string& n, int a) : name(n), age(a) {}

    // Friend function for output
    friend std::ostream& operator<<(std::ostream& os, const Person& p) {
        os << "Person{name=\"" << p.name << "\", age=" << p.age << "}";
        return os;
    }
};

int main() {
    Person alice("Alice", 30);
    Person bob("Bob", 25);
    
    // Now works like any built-in type!
    std::cout << alice << std::endl;
    std::cout << "Meeting: " << alice << " and " << bob << std::endl;
    
    return 0;
}

Overloading the Input Operator

Overloading the input operator (>>) allows custom classes to be read from input streams just like built-in types. This operator must modify the object being read into, so it takes a non-const reference to the class instance. It reads data from the stream in a specific format, extracts the values, and stores them in the object's member variables. Like the output operator, it returns a reference to the stream to enable chaining multiple input operations. This integration makes custom types work seamlessly with cin, file streams, and string streams, providing a consistent and intuitive interface for reading data.

#include <iostream>
#include <string>

class Point {
private:
    double x, y;
    
public:
    Point() : x(0), y(0) {}
    Point(double x, double y) : x(x), y(y) {}

    // Output operator
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {
        os << "(" << p.x << ", " << p.y << ")";
        return os;
    }

    // Input operator - expects format: x y
    friend std::istream& operator>>(std::istream& is, Point& p) {
        is >> p.x >> p.y;
        return is;
    }
};

int main() {
    Point p1(3.5, 4.2);
    std::cout << "Point 1: " << p1 << std::endl;
    
    std::cout << "Enter a point (x y): ";
    Point p2;
    std::cin >> p2;
    std::cout << "You entered: " << p2 << std::endl;
    
    return 0;
}

Complete Example: Date Class

This comprehensive example demonstrates a complete implementation of both input and output stream operators for a Date class. The Date class showcases advanced formatting techniques using manipulators like setfill() and setw() to produce standardized ISO 8601 date format (YYYY-MM-DD). The input operator includes format validation by checking for the expected dash separators and setting the stream's fail state if the format is incorrect. This example illustrates how stream operators can implement robust, user-friendly I/O for complex data types, with proper error handling and formatting control that matches industry standards for date representation.

#include <iostream>
#include <iomanip>
#include <sstream>

class Date {
private:
    int year, month, day;
    
public:
    Date(int y = 2000, int m = 1, int d = 1) : year(y), month(m), day(d) {}

    // Output: YYYY-MM-DD format
    friend std::ostream& operator<<(std::ostream& os, const Date& d) {
        os << d.year << "-"
           << std::setfill('0') << std::setw(2) << d.month << "-"
           << std::setw(2) << d.day
           << std::setfill(' ');  // Reset fill
        return os;
    }

    // Input: expects YYYY-MM-DD
    friend std::istream& operator>>(std::istream& is, Date& d) {
        char dash1, dash2;
        is >> d.year >> dash1 >> d.month >> dash2 >> d.day;

        // Validate format
        if (dash1 != '-' || dash2 != '-') {
            is.setstate(std::ios::failbit);
        }
        
        return is;
    }
};

int main() {
    Date today(2026, 2, 3);
    std::cout << "Today: " << today << std::endl;  // 2026-02-03
    
    // Parse from string
    std::istringstream iss("2025-12-25");
    Date christmas;
    iss >> christmas;
    std::cout << "Christmas: " << christmas << std::endl;  // 2025-12-25
    
    return 0;
}

class Rectangle {
private:
    int width, height;
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    // Add friend operator<< here
};

#include <iostream>

class Rectangle {
private:
    int width, height;
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    
    friend std::ostream& operator<<(std::ostream& os, const Rectangle& r) {
        os << "Rectangle(" << r.width << " x " << r.height << ")";
        return os;
    }
};

int main() {
    Rectangle rect(10, 5);
    std::cout << rect << std::endl;  // Rectangle(10 x 5)
    return 0;
}

class Temperature {
private:
    double celsius;
public:
    Temperature() : celsius(0) {}
    // Add friend operator>> and operator<< here
};

// Input: "25.5C"
// Output: 25.5°C

#include <iostream>
#include <sstream>

class Temperature {
private:
    double celsius;
public:
    Temperature() : celsius(0) {}
    
    friend std::istream& operator>>(std::istream& is, Temperature& t) {
        char unit;
        is >> t.celsius >> unit;
        if (unit != 'C' && unit != 'c') {
            is.setstate(std::ios::failbit);
        }
        return is;
    }
    
    friend std::ostream& operator<<(std::ostream& os, const Temperature& t) {
        os << t.celsius << "°C";
        return os;
    }
};

int main() {
    std::istringstream input("25.5C");
    Temperature temp;
    
    if (input >> temp) {
        std::cout << temp << std::endl;  // 25.5°C
    } else {
        std::cout << "Invalid format" << std::endl;
    }
    
    return 0;
}

class Point3D {
private:
    double x, y, z;
public:
    Point3D(double x=0, double y=0, double z=0) : x(x), y(y), z(z) {}
};

#include <iostream>
#include <sstream>

class Point3D {
private:
    double x, y, z;
public:
    Point3D(double x=0, double y=0, double z=0) : x(x), y(y), z(z) {}
    
    friend std::ostream& operator<<(std::ostream& os, const Point3D& p) {
        os << "(" << p.x << ", " << p.y << ", " << p.z << ")";
        return os;  // Enable chaining
    }
    
    friend std::istream& operator>>(std::istream& is, Point3D& p) {
        is >> p.x >> p.y >> p.z;
        return is;  // Enable chaining
    }
};

int main() {
    std::istringstream input("1.0 2.0 3.0 4.0 5.0 6.0");
    Point3D p1, p2;
    
    input >> p1 >> p2;  // Chained input
    std::cout << p1 << " to " << p2 << std::endl;  // Chained output
    // Output: (1, 2, 3) to (4, 5, 6)
    
    return 0;
}

class Time {
private:
    int hours, minutes, seconds;
public:
    Time(int h=0, int m=0, int s=0) : hours(h), minutes(m), seconds(s) {}
};

// Input: "09:05:30"
// Output: 09:05:30

#include <iostream>
#include <iomanip>
#include <sstream>

class Time {
private:
    int hours, minutes, seconds;
public:
    Time(int h=0, int m=0, int s=0) : hours(h), minutes(m), seconds(s) {}
    
    friend std::ostream& operator<<(std::ostream& os, const Time& t) {
        os << std::setfill('0') 
           << std::setw(2) << t.hours << ":"
           << std::setw(2) << t.minutes << ":"
           << std::setw(2) << t.seconds
           << std::setfill(' ');  // Reset
        return os;
    }
    
    friend std::istream& operator>>(std::istream& is, Time& t) {
        char colon1, colon2;
        is >> t.hours >> colon1 >> t.minutes >> colon2 >> t.seconds;
        
        if (colon1 != ':' || colon2 != ':') {
            is.setstate(std::ios::failbit);
        }
        return is;
    }
};

int main() {
    std::istringstream input("09:05:30");
    Time t;
    
    if (input >> t) {
        std::cout << t << std::endl;  // 09:05:30
    } else {
        std::cout << "Invalid time format" << std::endl;
    }
    
    return 0;
}