In competitive programming, the speed of input and output operations can be a deciding factor between an "Accepted" and a "Time Limit Exceeded" status. While standard C++ streams are convenient, their default behavior is often too slow for processing large datasets. This guide explores several layers of I/O optimization, from basic stream tweaks to custom fast I/O implementations.

1. Standard C++ Stream Optimization

The std::cin and std::cout streams are generally slower than C-style scanf and printf. This is primarily because C++ streams maintain synchronization with the C standard library's stdio buffers to allow mixing both styles in a single program. You can significantly improve performance by disabling this synchronization and unlinking the input and output streams.

#include <iostream>

int main() {
    // Disable synchronization with stdio
    std::ios_base::sync_with_stdio(false);
    
    // Untie cin from cout to prevent automatic flushing
    std::cin.tie(NULL);
    std::cout.tie(NULL);

    int value;
    if (std::cin >> value) {
        std::cout << value << "\n";
    }
    return 0;
}

2. The Pitfall of std::endl

A common mistake is using std::endl for line breaks. Unlike the character '\n', std::endl forces a buffer flush. Frequent flushing is computationally expensive and negates the benefits of buffered I/O. In almost all competitive programming scenarios, you should use '\n' instead.

// Slow: forces buffer flush
std::cout << result << std::endl;

// Fast: standard newline
std::cout << result << '\n';

3. Implementing Custom Fast I/O

When even optimized cin is too slow, manual character-by-character parsing using getchar() and putchar() provides the next level of performance. This approach bypasses the overhead of type-safe stream processing.

Fast Integer Reading

The following template function reads integers by consuming characters directly. It handles negative numbers and ignores non-numeric characters between inputs.

template <typename T>
inline void read_int(T &result) {
    result = 0;
    bool negative = false;
    char ch = getchar();

    while (ch < '0' || ch > '9') {
        if (ch == '-') negative = true;
        ch = getchar();
    }

    while (ch >= '0' && ch <= '9') {
        result = (result << 3) + (result << 1) + (ch - '0');
        ch = getchar();
    }

    if (negative) result = -result;
}

Fast Integer Writing

Similarly, writing integers can be optimized by storing digits in a local buffer and printing them in reverse order using putchar().

template <typename T>
inline void write_int(T val) {
    if (val < 0) {
        putchar('-');
        val = -val;
    }
    if (val == 0) {
        putchar('0');
        return;
    }

    static char buffer[32];
    int pos = 0;
    while (val > 0) {
        buffer[pos++] = (val % 10) + '0';
        val /= 10;
    }
    while (pos--) {
        putchar(buffer[pos]);
    }
}

4. Advanced Optimization with fread

For the most extreme performance requirements, fread can be used to read large chunks of the input file into a memory buffer at once. This minimizes the number of system calls and is significantly faster than repeated calls to getchar().

namespace FastIO {
    const int BUF_SIZE = 1 << 20;
    char buf[BUF_SIZE], *p1 = buf, *p2 = buf;

    inline char get_char() {
        if (p1 == p2) {
            p2 = (p1 = buf) + fread(buf, 1, BUF_SIZE, stdin);
            if (p1 == p2) return EOF;
        }
        return *p1++;
    }

    template <typename T>
    inline void read(T &x) {
        x = 0;
        T f = 1;
        char ch = get_char();
        while (ch < '0' || ch > '9') {
            if (ch == '-') f = -1;
            ch = get_char();
        }
        while (ch >= '0' && ch <= '9') {
            x = x * 10 + (ch - '0');
            ch = get_char();
        }
        x *= f;
    }
}

In modern C++14 and C++17 environments, the combination of sync_with_stdio(false) and '\n' is often sufficient for most problems. However, mastering fread and custom parsing logic is essential for tackling problems with extremely tight time limits or massive input volumes (e.g., millions of integers).