Why do we need to tie std::cin and std::cout?

Question

By default, the standard input device is tied together with the standard output device in the form: std::cin.tie (&std::cout); which guarantees that the output buffer has been flushed before input is invoked. So I try to untie them by using std::cin.tie(0), but it seems that the result, has no difference with the tied one.

#include<iostream>
using namespace std;

int main(int argc, char *argv[])
{
    char c;

    cin.tie(0)

    cout << "Please enter c:";
    cin >> c;
    cout << c ;

    return 0;
}

Am I testing wrong? Why do we need to tie them together? Do they share the same buffer?

The idea behind the tie is that the prompt should be displayed before reading the input. :-) — Bo Persson, Dec 27 '12 at 10:02

score 29 · Accepted Answer · edited Mar 03 '17 at 16:29

There is nothing wrong in your example (except that you should add a semi-colon after the cin.tie(0) line), nor with the way iostream objects work.

tie() simply guarantees the flushing of cout before cin executes an input. This is useful for the user to see the question before being asked for the answer.

However, if you un-tie() the cin from cout, there is no guarantee that the buffer of the cout is flushed. But there is no guarantee that the buffer is un-flushed neither. In fact, if the computer has enough resources, it will flush the cout buffer immediately, so this occurs before cin asking for the input. This is the case in your example.

So, everything works well. Except that after cin.tie(0), there is no guarantee that the flush-ing will occur. However, in 99% of the cases, that flush-ing will still occur (but it is no longer guaranteed).

In theory, if tied, cin and cout could share the same buffer. But, I think no implementation does that. One reason is that the two may be un-tie()d.

Minor nitpick: the tie only guarantees that `cout` will flush if (the `streambuf` underlying) `cin` has to ask the environment for more input. You won't get a flush if the `cin`'s input buffer contains enough data to satisfy the read request. — , Jun 30 '18 at 17:28
Nitpick the second: the reason `cout` gets flushed in the sample code is not about "resources" -- it's because synchronization with stdio is enabled by default, and so flushing happens by stdio's policy. In an (interactive) windows environment, by default the stdio output streams are totally unbuffered, so output happens immediately. (linux prefers line buffering in this situation, so the sample code wouldn't flush unless the buffer is so tiny that the prompt fills it) — , Jun 30 '18 at 17:31

score 9 · Answer 2 · answered Feb 24 '17 at 19:01

9

I think, previous answer is wrong (and I wonder why is it so upvoted and marked as true, being obviously not).

To break happens-before tie, you shall (in the case of standard io only) (1) remove sync with stdio and (2) untie streams.

Like this:

std::cin.tie (nullptr);
std::cout.sync_with_stdio(false);
std::cout << "Please enter c: ";
std::cin >> c;

Then you are guaranteed to have untied streams. Syncing with stdio is special ability in order to have proper happens-after ordering for C-style and C++-style input and output and I strongly discourage you from removing it without real necessity.

answered Feb 24 '17 at 19:01

Konstantin Vladimirov

6,791
1
27
36

Still get `Please enter c: ` after executing your code. – Itachi Uchiwa Sep 18 '19 at 19:11
Check that you std::cout is properly buffered. If it is unbuffered you will get immediate print of any character. – Konstantin Vladimirov Sep 19 '19 at 20:40
How can I do that? – Itachi Uchiwa Sep 19 '19 at 21:44
Basically rdbuf shall return non-null and unitbuf flag shall not be set in flags – Konstantin Vladimirov Sep 21 '19 at 06:51

score 2 · Answer 3 · answered Jun 30 '18 at 18:09

In C, prompting the user for input followed the pattern where you issued a command to print a prompt message, and then a command to input a value.

In order for this process to work properly, you need to ensure the prompt message is actually displayed. Environments were configured so that this was automatic:

In a DOS (or windows command line) environment, STDOUT is unbuffered, so the print command displays the message immediately.
In a *NIX environment, STDOUT is line buffered. So, if you followed the *NIX style of including a newline in your prompt message so that the user enters input on the next line, your prompt would display automatically before input.

The tie feature makes this behavior of automatic flushing part of the way in which the iostream library works, rather than a product of convention. (although be aware that the automatic flushing only happens when the program asks the system to obtain more input, so there are edge cases where cin >> c won't actually flush)

However! By default the iostream library is synchronized with the stdio library. In practice, this means the iostream doesn't do any buffering at all; it simply forward the data over to the underlying C library.

So, this means you're seeing what you what you would normally see if you wrote a similar C program. If you are in a windows command line environment, output wouldn't be buffered, and so you see the prompt before entering input.

To see the native C++ behavior, you need to turn off synchronization by running std::cout.sync_with_stdio(false); at the start of your program, as indicated in the other answer.

If you do that, then the cout statement won't flush the output buffer (unless the buffer is very tiny). And since you've removed the tie, the cin statement won't flush it either. So, you'll get the result where you have to enter user input before you see the prompt.

Why do we need to tie std::cin and std::cout?

3 Answers3

Linked

Related