# How to optimize IO in C++ > Source: > Published: 2026-06-26 18:18:37+00:00 [Link to the repository containing all examples](https://github.com/MiztonCodes/OptimizeIO) Back when I was at my first class of Data Structures and Algorithms, I started to solve competitive programming questions in judges like CodeForces, I didn't know why my code was slower if my solution was efficient (at least in theory), my professor explain to the class the reason why our programs were slow, because of I/O is an expensive task for computers. To start working with the examples in this article just clone the repository and play with it as long the article explains how to run the code. ``` git clone https://github.com/MiztonCodes/OptimizeIO.git ``` `std::cout` and `std::cin` are slow? In C++ by default, both `std::cin` and `std::cout` streams are synchronized with standard C `scanf` and `printf` streams and at the same time every single call to `std::cin` flushes the `std::cout` buffer, because `std::cin` before reading input, wants to output any pending prompt to the user, which can cause performance issues because reading and writing are expensive tasks due to the need to make calls to the operating system, the solution is to disable all of this synchronizations and manually flushing the output buffer whenever it is needed. *Note: For convenience in all examples I'll use #include header to simplify the imports, this header includes everything we'll need and this header only works on GCC compiler.* When you run your program, it is like an isolated box inside your computer, ready to do some work, the **input** process involves moving raw data from an external source like a keyboard, a file or even the network to your program *(reading)*, the **output** process involves moving data from your program to an external destination like a monitor, the console, a file, the network or even an external device *(writing)*, for both processes your program does not read or write directly to the **input** and **output** sources, because each source has its own way to transfer data, C++ provides a uniform interface to hide that complexity through the usage of **streams**. In C++ and other programming languages, a **stream** is an abstraction layer that hides the complexity of dealing with external sources to *read* and *write* data from your program, so you can use a unified interface with the following operators for writing `dest << data` and reading `source >> dest` . The **stream** is able to translate the raw input data into data types that your program can understand like `int` , `bool` , `char` , so basically the **stream** is only responsible to transport data. A **buffer** is a contiguous block of memory located at the RAM, reserved to *batch* data to reduce the amount of calls to the operating system, once the **buffer** has reached its full capacity the operating system performs one single efficient transfer of **buffer's** data to its final destination, so the memory of the **buffer** can be reused and then wait until the **buffer** reached its full capacity again, this makes **buffers** the perfect place to hold data during your program execution. As in real life the travel from shorter distances almost always implies shorter travel times and plus the planning time, reading and writing data is expensive because the data must travel from one location to its destination and at same time the CPU needs to manage the transfer of data. Reading and writing data implies much more than just moving data from one location to its destination, when a reading or writing operation is needed a call to the operating system is made and the process first makes the CPU to switch the context of whatever it was doing before, then verifies permission and perform operations on memory to finally move the data, while all this happens the CPU spends a lot time and operations waiting to move the data to its destination. This is due to the C++ history, C++ at first was C with classes, nowadays to keep compatibility and consistency it keeps synchronized standard input and output streams, so you can mix both styles in a single program and expects the output order be preserved when mixing both styles, but it introduces performance issues, especially when you don't need that synchronization like in competitive programming or newer projects where compatibility with C is not needed. As I said earlier, just disable all synchronizations and manually flush the output stream when needed, just add the following lines to the beginning of your `main` function. **Warning: When you disable synchronization, don't mix both styles because it can produce an undefined behavior** ``` // Disable synchronization with standard C scanf and printf streams std::ios_base::sync_with_stdio(false); // Disable synchronization between std::cin and std::cout streams std::cin.tie(nullptr); ``` *Note: You only need to untie std::cin like in the code snippet above because std::cout is not tied to anything, so just remember to only untie std::cin.* To demonstrate performance gains, you can run the following tests to verify it by yourself. *Note: To demonstrate a noticeable performance gain, use as input the dataset.txt file hosted in the repository of this example, this file has a size of 75 MB and contains 10 million integer numbers from 1 to 10'000'000 this is a really simple example to demonstrate performance gains even when your program only read data and don't perform any other computation.* To compile and run the next examples just use the following commands. ``` # Move the section directory cd 01_Optimize_Writing # Give execution permissions to compilation scripts chmod +x run_without_optimization.sh chmod +x run_with_optimization.sh # Run the examples below ./run_without_optimization.sh ./run_with_optimization.sh #include int main() { // Get the current time before executing the heavy part. auto start = std::chrono::high_resolution_clock::now(); // Heavy part reading data. int val = 0; for (long long i = 0; i < 10'000'000; ++i) { std::cin >> val; } // Get the current time after executing the heavy part. auto end = std::chrono::high_resolution_clock::now(); // Calculate the exeuction time lapse. std::chrono::duration diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count() << " seconds" << std::endl; } ``` You will get an output like this ``` Time taken: 5.39379 seconds #include int main() { // Optimization std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); // Get the current time before executing the heavy part. auto start = std::chrono::high_resolution_clock::now(); // Heavy part reading data. int val = 0; for (long long i = 0; i < 10'000'000; ++i) { std::cin >> val; } // Get the current time after executing the heavy part. auto end = std::chrono::high_resolution_clock::now(); // Calculate the exeuction time lapse. std::chrono::duration diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count() << " seconds" << std::endl; } ``` You will get an output like this ``` Time taken: 0.667611 seconds ``` Even in this really simple example we can observe a performance gain of five times faster execution, just disabling the synchronization of streams. Avoid the usage of `std::endl` to add a line break , because `std::endl` add a line break and at the same time it flushes the buffer (which is an expensive operation), so if you only want to add a line break just use the `\n` character like in the next example: ``` /* Avoid this style to add line breaks, it will add a line break at the end of the string and flush the output buffer which will cause performance issue. */ std::cout << "Woody!" << std::endl; /* Prefer this style to add line breaks, it will add a line break at the end of the string and will not flush the output, so the string is going to be batched at the output buffer, */ std::cout << "Woody!\n"; ``` To demonstrate performance gains, you can run the following tests to verify it by yourself. To compile and run the next examples just use the following commands. ``` # Move the section directory cd 01_Optimize_Reading # Give execution permissions to compilation scripts chmod +x run_without_optimization.sh chmod +x run_with_optimization.sh # Run the examples below ./run_without_optimization.sh ./run_with_optimization.sh ``` `std::endl` ``` #include int main() { /* In this case the following lines does not affect in any case because we are not reading data. */ std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); // Get the current time before executing the heavy part. auto start = std::chrono::high_resolution_clock::now(); // Heavy part writing data. for (int i = 1; i <= 10'000'000; ++i) { std::cout << "Iteration " << i << std::endl; } // Get the current time after executing the heavy part. auto end = std::chrono::high_resolution_clock::now(); // Calculate the exeuction time lapse. std::chrono::duration diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count() << " seconds" << std::endl; } ``` You will get an output like this ``` Time taken: 5.76418 seconds ``` `\n` ``` #include int main() { /* In this case the following lines does not affect in any case because we are not reading data. */ std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); // Get the current time before executing the heavy part. auto start = std::chrono::high_resolution_clock::now(); // Heavy part writing data. for (int i = 1; i <= 10'000'000; ++i) { std::cout << "Iteration " << i << "\n"; } // Get the current time after executing the heavy part. auto end = std::chrono::high_resolution_clock::now(); // Calculate the exeuction time lapse. std::chrono::duration diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count() << " seconds" << std::endl; } ``` You will get an output like this ``` Time taken: 1.47316 seconds ``` Even in this really simple example we can observe a performance gain of five times faster execution, just by not flushing the output buffer every single time we need to add a line break. To compile and run the next examples just use the following commands. ``` # Move the section directory cd 02_Miscellaneous # Give execution permissions to compilation scripts chmod +x run_error_log.sh chmod +x run_format_output.sh chmod +x run_redirect_io.sh chmod +x run_operator_overloading.sh # Run the examples below ./run_error_log.sh ./run_format_output.sh ./run_redirect_io.sh ./run_operator_overloading.sh ``` `std::cerr` stream for errors and diagnostics In addition to the standard `std::cin` reading and `std::cout` writing streams, C++ provides another `std::cerr` stream to write errors and diagnostic data, the difference between `std::cout` and `std::cerr` is mainly the way each of them outputs data, while `std::cout` holds data in a buffer, `std::cerr` is unbuffered and outputs data immediately after a call to it, so if you use `std::cout` and the program execution is interrupted, the output buffer is going to be destroyed along the program and data stored in the buffer will be lost. ``` #include int main() { std::cout << "First std::cout call\n"; std::cerr << "Using this to print error messages and diagnostic data.\n"; std::cout << "Second std::cout call\n"; } ``` You will get this output ``` First std::cout call Using this to print error messages and diagnostic data. Second std::cout call ``` As you can read a call to `std::cerr` writes immediately to the console because it is unbuffered. If you are using C++20 or higher, you can use the modern `std::format` to print in fixed-point, and scientific notations like in the following example. ``` #include int main() { double my_number = 7.2069; // Default formatting std::cout << std::format("Default notation: {}\n", my_number); // Fixed-point and rounded up with 2 decimal places std::cout << std::format("Fixed and rounded up (2 decimal): {:.2f}\n", my_number); // Fixed-point and floored with 2 decimal places std::cout << std::format("Fixed and floored (2 decimal): {:.2f}\n", std::floor(my_number)); // Fixed-pint and ceiled with 2 decimal places std::cout << std::format("Fixed and ceiled (2 decimal): {:.2f}\n", std::ceil(my_number)); // Scientific notation std::cout << std::format("Scientific and rounded up: {:.2e}\n", my_number); return 0; } ``` You will get an output like this ``` Default notation: 7.2069 Fixed and rounded up (2 decimal): 7.21 Fixed and floored (2 decimal): 7.00 Fixed and ceiled (2 decimal): 8.00 Scientific and rounded up: 7.21e+00 ``` This is useful when you need to deal with decimal places and rounding decimal numbers based on the question requirements. It is very tedious to read and write data directly from the terminal, and have mixed output along with logs, errors, diagnostics and output data, so you can redirect all of this input and output categories to files in your filesystem when you execute the program. The operating system has multiple channels to read and write data, so when you run your program you can redirect channels to files like in the following example. ``` ./bin 0< input.txt 1> output.txt 2> errors.txt ``` And you can still use `std::cin` , `std::cout` and `std::cerr` just like any other program and have a more cleaner workspace, this is helpful if you have a really large `input.txt` dataset file and copy pasting to the terminal is not an option. *Extra: There is also an standard std::log stream that is buffered and writes data to the error channel, use it only when you need to write some extra information but you don't need it immediately.* In C++ you can keep using `std::cin` and `std::cout` but redirect the streams to read and write from a custom string or a file streams and then rollback the original ones to read and write from the standard input and output. In the following example a **RAII** *(Resource Acquisition Is Initialization)* pattern is implemented to ensure the swap and rollback of buffers is secure even if an exception happens or the program ends early. *Note: You can run this example using the files provided at the repository of the article.* ``` #include /* This class will hold the overall logic to swap buffers given a stream and a new buffer using the RAII pattern. */ class stream_redir { private: // Holds the stream std::ios& _stream; // Holds the original buffer of the stream std::streambuf* _origin_buff; public: /* The constructor will save a reference to the stream and will hold a pointer to the original buffer while assigning the new buffer to the stream. */ stream_redir( std::ios& stream, std::streambuf* new_buffer ): _stream(stream), _origin_buff(stream.rdbuf(new_buffer)) {} // The destructor automatically restores the original buffer. ~stream_redir() { _stream.rdbuf(_origin_buff); } // Prevent copying to avoid multiple restorations of the same buffer. stream_redir(const stream_redir&) = delete; stream_redir operator=(const stream_redir&) = delete; }; void redirect_output_to_string() { std::cout << "=== REDIRECT OUTPUT TO A STRING ===\n"; std::stringstream custom_out; std::cout << "Before redirection\n"; // In this scope the redirection will happens. { stream_redir redir(std::cout, custom_out.rdbuf()); std::cout << "This message is going to be stored at custom_out buffer"; } // At the end of the scope, buffer restoration happens. std::cout << "After redirection\n"; std::cout << "custom_out contents:\n"; std::cout << custom_out.rdbuf() << "\n"; } void redirect_input_to_string() { std::cout << "=== REDIRECT INPUT TO A STRING ===\n"; std::string input_data = "I'm happy learning C++"; std::stringstream custom_in(input_data); std::string read_data; read_data.reserve(input_data.size()); // In this scope the redirection will happens. { stream_redir redir(std::cin, custom_in.rdbuf()); while (std::getline(std::cin, read_data)) {} } // At the end of the scope, buffer restoration happens. std::cout << "read_data contents:\n"; std::cout << read_data << "\n"; } void redirect_output_to_file() { std::cout << "=== REDIRECT OUTPUT TO A FILE ===\n"; std::filebuf custom_out; custom_out.open("dataset_temp.txt", std::ios::out); std::vector nums{1, 2, 3, 4, 5}; std::cout << "Before redirection\n"; // In this scope the redirection will happens. { stream_redir redir(std::cout, &custom_out); for (const int& n : nums) { std::cout << n << "\n"; } } // At the end of the scope, buffer restoration happens. std::cout << "After redirection\n"; } void redirect_input_to_file() { std::cout << "=== REDIRECT INPUT TO A FILE ===\n"; std::filebuf custom_in; // Here read data from the file created by redirect_output_to_file function custom_in.open("dataset_temp.txt", std::ios::in); constexpr size_t MAX_NUM_SIZE = 5; std::vector nums; nums.reserve(MAX_NUM_SIZE); std::cout << "Before reading nums.size() == " << nums.size() << "\n"; // In this scope the redirection will happens. { stream_redir redir(std::cin, &custom_in); for (size_t i = 0; i < MAX_NUM_SIZE; ++i) { int n = 0; std::cin >> n; nums.push_back(n); } } // At the end of the scope, buffer restoration happens. std::cout << "After reading nums.size() == " << nums.size() << "\n"; for (const auto& n : nums) std::cout << n << " "; std::cout << "\n"; } int main() { // Optimization for reading and writing std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); // Examples redirect_output_to_string(); redirect_input_to_string(); redirect_output_to_file(); redirect_input_to_file(); } ``` You will get an output like this ``` === REDIRECT OUTPUT TO A STRING === Before redirection After redirection custom_out contents: This message is going to be stored at custom_out buffer === REDIRECT INPUT TO A STRING === read_data contents: I'm happy learning C++ === REDIRECT OUTPUT TO A FILE === Before redirection After redirection === REDIRECT INPUT TO A FILE === Before reading nums.size() == 0 After reading nums.size() == 5 1 2 3 4 5 ``` So as you can see, the streams can be redirected to read and write data to other sources, this is useful for testing when you try to mock certain input or output sources while keep using the standard input and output streams. Sometimes you will need to read and write data based on a format or structure, for example to read data and create an instance of a class or struct, maybe you want to print all your vector public members to a certain format so other programs can understand your data. In C++ you can overload the `<<` output operator and the `>>` input operator to work with complex data types like in the next example. ``` #include namespace mizton { struct vector_3d { int x, y, z; }; }; /* Overloading of output operator on output streams. */ std::ostream& operator<<(std::ostream& os, const mizton::vector_3d& v) { os << "vector{" << v.x << "," << v.y << "," << v.z << "}\n"; return os; } /* Overloading of input operator on input streams. */ std::istream& operator>>(std::istream& is, mizton::vector_3d& v) { int x = 0, y = 0, z = 0; /* In this case we don't allow negative numbers as coordinate values, so we will set the read operation as failed, so the calling code can handle the error. */ if (is >> x >> y >> z) { if (x < 0 || y < 0 || z < 0) { is.setstate(std::ios::failbit); // Indicates input conversion fails std::cerr << "Negative coordinate value can't be converted to a mizton::vector_3d structure\n"; } else { v.x = x; v.y = y; v.z = z; } } else { is.setstate(std::ios::badbit); // Indicates a loss of integrity std::cerr << "Lost data while trying to read a mizton::vector_3d structure\n"; } return is; } int main() { // Mock input stream std::stringstream input_stream(R"( 3 1 0 1 1 0 3 5 6 1 )"); // Reading from input_stream int vector_size = 0; input_stream >> vector_size; assert(vector_size >= 0); // Ensure the first number read is positive std::vector v_list(vector_size); for (int i = 0; i < vector_size; ++i) { /* If input reading fails, just ends the program normally performing a clean up of variables and calling destructors and return exit code of a failure. */ if (!(input_stream >> v_list[i])) { return EXIT_FAILURE; } } // Writing data to standard output for (const auto& v : v_list) { std::cout << v; } return EXIT_SUCCESS; } ``` After running the code above, you will get an output like this ``` vector{1,0,1} vector{1,0,3} vector{5,6,1} ``` If you change some of the values for vectors to negative, the program will ends and an error like this will be out ``` Negative coordinate value can't be converted to a mizton::vector_3d structure ``` In real life, using streams and buffers in C++ can be really complex and allow us to create really performant systems, I have shared what I found useful to deal with, especially when I was working with online judges like **CodeForces** to test my solution.