CODEWITHSUNDEEP
c++iostreamflush
SLN
SLN

Reputation: 5082

Why reading from a stream does not require a buffer flush

Just started C++ learning by C++ Primer 5th ed.

The very first example of the book on page 6 is as followed

#include <iostream>
int main()
{
    std::cout << "Enter two numbers:" << std::endl; 
    int v1 = 0, v2 = 0; 
    std::cin >> v1 >> v2;
    std::cout << "The sum of " << v1 << " and " << v2
        << " is " << v1 + v2 << std::endl;
    return 0;
}

The manipulator endl insert newline and flush the buffer.

soon followed by the code snipe in the page 7, the author emphasized that

Programmers often add print statements during debugging. Such statements should always flush the stream. Otherwise, if the program crashes, output may be left in the buffer, leading to incorrect inference about where the program crashed

From the code example and the emphasized warning I feel it is important to do the flush when writing to a Stream

Here is the part I don't understand, how a bout reading from a stream case, such as std::cin, is there any necessary to do the flush then?

Appended Question： 

#include <iostream>

int main()
{
    int sum = 0, val = 1;
    while (val <= 5) {
        sum += val;
        ++val;
        std::cout << sum << std::endl; //test
    }
}

When I changed the line marked with test to std::cout << sum << '\n';, there is no visual difference in the console. Why is that, isn't it supposed to print as follows if there is no flush for each loop?

1
1 3
1 3 6 
1 3 6 10
1 3 6 10 15

Thanks

Upvotes: 0

Views: 574

Answers (2)

SLN
SLN

Reputation: 5082

Quote from the same book page 26:

Buffer A region of storage used to hold data. IO facilities often store input (or out-put) in a buffer and read or write the buffer independently from actions in the program. Output buffers can be explicitly flushed to force the buffer to be written. Be default, reading cin flushes cout; cout is also flushed when the program ends normally.

Upvotes: 0

wolff
wolff

Reputation: 436

Even if @Klitos Kyriacou is right when he says you should create a new post for a new question, it seems to me that both your questions arise from the same misunderstanding.

Programmers often add print statements during debugging. Such statements should always flush the stream. Otherwise, if the program crashes, output may be left in the buffer, leading to incorrect inference about where the program crashed

This quote does not mean that you need to flush every buffer in your program to create any output on the console. By flushing the buffers you can make sure that the output is printed before the next line of code is executed. If you don't flush the buffers and your program finishes, the buffers will be flushed anyway.

So, the reason you see the same output on the console with std::endl and \n is, that exactly the same text is printed to the console. In the former case, the output might be there slightly earlier, as the buffers are flushed early. In the latter case, the buffers are flushed later, but they will be flushed at some time.

What the quote talks about is the case when your program does not exit gracefully, e.g. when your program crashes or is interrupted by the OS. In these cases, your output might not be written to the console when you did not explicitly flush the buffers. What the quote wants you to know is: Whenever you want to debug a program that crashes, you should explicitly flush the buffers to make sure your debug output is printed to the console before your program is interrupted.

Note that this might not be true for all implementations.

From http://en.cppreference.com/w/cpp/io/manip/endl

In many implementations, standard output is line-buffered, and writing '\n' causes a flush anyway, unless std::ios::sync_with_stdio(false) was executed.

Upvotes: 2

Related Questions