Yes, you are correct.

I think it would be good to reiterate what tie does because I see a lot of people copying these lines with only a vague understanding of what they do.

Every stream in C++ is tied to an output stream, which can be null.

What does this mean? First of all, it's important to understand that when you write std::cout << "asdf", it is not necessarily immediately printed on the screen. It turns out that it is much better (in terms of performance) to collect it into a buffer and then, at some point, flush the buffer — i.e. empty its contents to the screen (or file, or any other "device"), all at once.

But now, consider the following. You are developing a console application and write something like:

1 std::cout << "Please enter your age: ";
2 int age;
3 std::cin >> age;

What would happen if std::cout didn't get flushed before line 3? The program would expect a reply from the user, but the user hasn't even had a chance to read the question. In an application like this, it would be a good idea if std::cout was somehow automatically flushed when we try to read from std::cin.

And this is exactly the problem tie solves. If you have two streams fin and fout, and fin is tied to fout, then fout is automatically flushed when you try to read from fin. So what are the defaults? What is tied to what? Quoting the C++ reference:

By default, the standard narrow streams cin and cerr are tied to cout, and their wide character counterparts (wcin and wcerr) to wcout. Library implementations may also tie clog and wclog.

Now it becomes clear why people recommend using cin.tie(0) in competitive programming. Suppose you are solving a query problem like this.

1 MyAwesomeDataStructure ds;
2 for (int i = 0; i < queryc; i++) {
3   Query q;
4   cin >> q;
5   cout << ds.solve(q) << '\n';
6 }

If you didn't use cin.tie(0), we would flush cout every time we hit line 4; this is essentially as bad as writing endl on line 5. Concerns about the user not seeing the question are also irrelevant now because we are given the entire input at once.

The reference doesn't explicitly say that cout isn't tied to anything, but on every C++ compiler I tried, cout << cout.tie() << endl; outputs 0. Also, even if you are using some strange compiler that ties cout to some other stream sout, you would only notice the performance hit if you wrote a lot to sout which doesn't really happen in competitive programming.

So yes, cout.tie(0) doesn't do anything and in some sense it's a sign that the user doesn't understand cin.tie(0) very well either.

Thank you!

I've seen your comments a lot lately on a lot of blogs. Now I think you're the one seeking +ve contribution.

You're absolutely right. This question isn't about practice usage. I'm just interested in this.

I think there isn't actually any need for fast IO in interactive problems most of the time because we use flush and it's really slow. But at the same time, there is no reason not to use fast IO always.

Both do same
But I'd say first is preferable since second way is confusing. sync_with_stdio is static method and it supposed to be called as static not as member of cout.

I have tried to submit the linked code with and without cout.tie(NULL) and it was accepted both times. No ideas where to find a good idea :)

Can you please provide the problem link?

Quoting purplesyringa:

// If you use std::cout.tie(nullptr);, you are wrong.
// This won't ever be supported.
// You don't need this line. Remove it.
// You have almost certainly added 12 useless bytes to every solution. They take space on disk.
// Disks are produced by young children on factories. Do you want children to work more because
// of you? Think of the children.
// And about yourself too. One of the pictures on this page is loaded from my domain. I know your IP.

Thanks for the information. I've been using that in my template all the time lol. I'll change it on polygon soon.