N 或 n 或 std: : endl to std: : cout？

从我写到 std::cout时停止使用 std::endl作为结束行到现在已经有很多年了，而是开始使用 "\n"。

但是现在我开始看到更多使用 '\n'的代码片段，我开始想知道什么可能是最好的。

除了显而易见的一个是字符串，另一个是字符之外，使用这种方法还有什么好处:

std::cout << variable << '\n';

在这方面:

std::cout << variable << "\n";

后期补充:

当我问这个问题时，我似乎认为换行 '\n'刷新了缓冲区。现在我知道它 看情况。

默认情况下，std::cin绑定到旧的 CstdinFILE*流，而 std::cout绑定到 stdout。换行时的冲水就是这种打结的结果。默认情况下，如果连接到终端，stdout是线路缓冲的。这意味着新行将刷新其缓冲区。因此，当使用 std::cout打印换行时，将导致 stdout被刷新。

如果 stdout没有连接到终端(例如输出已经被重定向或管道连接) ，或者如果 std::cout和 stdout之间的连接被打破，那么换行将不会刷新任何内容。

73323 次浏览
小开

There are no the best. You use what you need :

  • '\n' - to end the line
  • "some string\n" - the end the line after some string
  • std::endl - to end the line and flush the stream
小开

Edit: I worded my answer poorly, which may have lead people to believe that I thought "\n" actually printed a null character. This is of course wrong :)

Edit 2: Having looked at a C++ reference, chars are passed by reference anyway, so there's no difference there. The only difference is that the cstring will have to be searched for a delimiting character. The below isn't correct due to this fact.

'\n' would be ever so slightly more efficient than "\n", because the latter also contains a null character on the end, which means you're sending a char* to operator<<() (usually 4 bytes on a 32-bit system) as opposed to a single byte for a char.

In practice, this is borderline irrelevant. Personally, I follow the convention that Vladimir outlined.*

小开
最佳答案

Actually, '\n' should be the default. Unless you want to also explicitly flush the stream (and when and why would you want to do that?), there is no need to use std::endl at all.1
Of course, many books and tutorials use std::endl as the default. That is unfortunate and might lead to serious performance bugs.

I suppose there's little difference between using '\n' or using "\n", but the latter is an array of (two) characters, which has to be printed character by character, for which a loop has to be set up, which is more complex than outputting a single character. Of course, when doing IO this rarely matters, but if in doubt, when you want to output one character literal, output a character literal, rather than a whole string literal.
A nice side-effect of doing so is that you communicate in your code that you intended to output only a single character, and not just accidentally did this.

1 Note that std::cout is tied to ABC1 by default, which leads to std::cout being flushed before any input operation, so that any prompt will be printed before the user has to input something.

小开

They do different things. "\n" Outputs a newline (in the appropriate platform-specific representation, so it generates a "\r\n" on Windows), but std::endl does the same and flushes the stream. Usually, you don't need to flush the stream immediately and it'll just cost you performance, so for the most part there's no reason to use std::endl.

小开

std::endl flushes the stream. When this something you want to happen -- e.g. because you expect your output to be made visible to the user in a timely fashion -- you should use std::endl instead of writing '\n' to the stream (whether as an isolated character or part of a string).

Sometimes, you can get away without explicitly flushing the stream yourself; e.g. in a linux environment, if cout is synchronized with STDOUT (this is the default) and is writing to a terminal, then by default, the stream will be line buffered and will automatically flush every time you write a new line.

However, it is risky to rely on this behavior. e.g. in the same linux environment, if you decide to run your program with stdout being redirected to a file or piped to another process, then by default, the stream will be block buffered instead.

Similarly, if you later decide to turn off synchronization with stdio (e.g. for efficiency), then implementations will tend to use iostream's buffering mechanisms, which doesn't have a line buffering mode.

I have seen much wasted productivity due to this mistake; if output should be visible when it is written, then you should either use std::endl explicitly (or use std::flush or std::ostream::flush, but I usually find std::endl more convenient), or do something else that ensures flushing happens often enough, such as configuring stdout to be line buffered (assuming that's adequate).

小开

  • std::cout << variable << std::endl;

    std::endl output a newline, but it also flushes the output stream. In other words, same effect as 

    std::cout << variable << '\n'; // output newline
std::cout.flush();      // then flush

  • std::cout << variable << '\n';

    '\n' output a newline for a char, hence ostream& operator<< (ostream& os, char c); will be used.

  • std::cout << variable << "\n";

    "\n" is a const char[2], so ostream& operator<< (ostream& os, const char* s); will be used. We can imagine, this function will contain a loop, we might argue is overkill to just print out a newline.


提交答案