blocks|key|804574|text|也许是因为它看起来类似于Unix的append操作，因为您本质上是在附加到输入/输出流？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804575|例如。|804576|输出|804577|echo+"foo"+>>+bar|offset|length|style|CODE|804578|输入|804579|sendmail+-f+test@domain.com+<<+myemail.txt|804580|(从Zac+Howland窃取输入示例)|804581|entityMap^0|0|0|0|0|H|0|0|0|16|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@$H|X|I|Y|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@$H|11|I|12|J|K]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|S|$]]

Maybe because it looks similar to the Unix append operation, as you are essentially appending to an input/output stream?

E.g.

<h3>Output</h3>

<code><code>echo "foo" &gt;&gt; bar</code></code>

<h3>Input</h3>

<code>sendmail -f test@domain.com &lt;&lt; myemail.txt</code>

(Stole input example from Zac Howland)

blocks|key|1019256|text|因此，请记住，如果您将cin视为键盘，将cout视为监视器，则您键入的内容将进入变量|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1019257|cin>>var;|code-block|syntax|javascript|1019258|否则变量的内容就会显示在屏幕上|1019259|cout<<var;|1019260|entityMap^0|B|3|K|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

So you remember that if you think <code>cin</code> as a keyboard and <code>cout</code> as a monitor, what you type goes into the variable

<pre><code>cin&gt;&gt;var;
</code></pre>

Or the contents of your variable goes towards the screen

<pre><code>cout&lt;&lt;var;
</code></pre>

blocks|key|804683|text|>>和<<只是运算符，您可以为您的类实现自己的>>和<<。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|804684|我认为“有人”选择它们是因为:+a)它们类似于shell文件操作，b)重用现有运算符，因为不需要创建新的运算符|804685|entityMap^0|0|2|3|2|N|2|Q|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

<code>&gt;&gt;</code> and <code>&lt;&lt;</code> are just operators and you can implement your own <code>&gt;&gt;</code> and <code>&lt;&lt;</code> for your classes.

I suppose "somebody" selected them because: a) they are similar to shell file operations and b) to reuse existing operators because there are no need to create new ones

blocks|key|804961|text|因为他们或多或少有一个合理的优先顺序，而且看起来不错。在C%2B%2B中，您不能创建新运算符或更改其优先级或分组规则，只能重载现有运算符并更改它们的实际操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804962|选择<<和>>有一些不幸的副作用，因为它以某种方式推动了这样一种想法，即输出将根据顺序完成。虽然这对于实际输出是正确的，这要归功于一种巧妙的链接技巧，但对于涉及的计算来说，它却是错误的，这经常令人惊讶。|offset|length|style|CODE|804963|更具体地说，写作|804964|std::cout+<<+foo()+<<+bar()+<<+std::eol;|code-block|syntax|javascript|804965|并不意味着将在bar之前调用foo。|804966|编辑|804967|在C%2B%2B17中，序列问题已经“修复”了。现在，<<和>>运算符的求值顺序被指定为从左到右。在C%2B%2B中，仍然有一些地方的求值顺序是未指定的(甚至不存在，这意味着求值可以交错)，但一些常见的情况现在以一种可预测和可移植的方式表现出来，请参见this+answer。|804968|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/38501596/320726^0|0|2|2|5|2|0|0|0|7|3|E|3|0|0|N|2|Q|2|3A|B|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@$D|1L|E|1M|1|1N]]|A|$]]|$1|U|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

Because they had more or less a reasonable precedence and looked good. In C++ you cannot create new operators or change their precedence or grouping rules, you can only overload existing ones and changing what they actually do.

The choice of <code>&lt;&lt;</code> and <code>&gt;&gt;</code> has some unfortunate side effect because it's somehow pushing the idea that the output will be done respecting the order. While this is true for the actual output thanks to a clever chaining trick it's however false for the computations involved and this is very often surprising.

To be more specific writing

<pre><code>std::cout &lt;&lt; foo() &lt;&lt; bar() &lt;&lt; std::eol;
</code></pre>

does NOT imply that <code>foo</code> will be called before <code>bar</code>.

<h1>EDIT</h1>

With C++17 the sequence problem has been "fixed". Now the order of evaluation is specified to be left-to-right for <code>&lt;&lt;</code> and <code>&gt;&gt;</code> operators. There are still places in C++ where the order of evaluation is unspecified (or even non-existing meaning that evaluation can be interleaved) but a few common cases now behave in a predictable and portable way see <a href="https://stackoverflow.com/a/38501596/320726">this answer</a> .

blocks|key|804722|text|它们不是按位运算符，在此上下文中称为插入运算符和提取运算符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804723|http://www.cplusplus.com/doc/tutorial/basic_io/|offset|length|804724|这些仅用于视觉解释。如果您学习开发自己的流和运算符重载，那么您甚至可以使用%2B表示输入，使用-表示输出:)|804725|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1B|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

They are not bitwise operators, They are called insertion and extraction operators in this context.

<a href="http://www.cplusplus.com/doc/tutorial/basic_io/" rel="nofollow">http://www.cplusplus.com/doc/tutorial/basic_io/</a>

These are used only for visual interpretation. If you study developing own stream and operator overloading, then you can see that you can even use + for input and - for output :)

blocks|key|1019526|text|主要是因为它们的关联性。插入和提取运算符从左到右关联，因此|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1019527|std::cout+<<+"Hello"+<<+'+'+<<+4+<<+2;|code-block|syntax|javascript|1019528|按照您的预期进行计算:首先使用"Hello"，然后使用'+'，最后使用4和2。加法运算符operator%2B也从左到右关联。但是这个运算符和其他具有从左到右关联性的运算符已经有了不同的含义。|offset|length|style|CODE|1019529|entityMap^0|0|0|F|7|R|3|Z|1|11|1|18|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

Mostly because of their associativity. The insertion and extraction operators associate from left to right, so

<pre><code>std::cout &lt;&lt; "Hello" &lt;&lt; ' ' &lt;&lt; 4 &lt;&lt; 2;
</code></pre>

evaluates as you'd expect: first with <code>"Hello"</code>, then with <code>' '</code> and finally with <code>4</code> and <code>2</code>. Granted, the addition operator, <code>operator+</code> also associates from left to right. But that operator and others with left-to-right associativity already have a different meaning.

blocks|key|1019393|text|这个答案并不令人满意，但却是正确的:它们不是按位运算符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1019394|运算符的含义由其左侧显示的数据类型确定。在cin和cout+(以及其他流类型)的情况下，<<和>>运算符在流中来回移动值。在左操作数是整数的情况下，操作是您在C中已经知道的按位操作。|1019395|运算符的含义不是固定的，尽管它的优先级是固定的。|1019396|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This answer is unsatisfying but correct: they aren't bitwise operators.

The meaning of the operator is determined by the data-type that appears on its left. In the case of cin and cout (and other stream types) &lt;&lt; and >> operators move values to and from streams. In the case that the left operand is an integer, the operation is the bitwise operation that you already know from C.

The meaning of the operator is not fixed, although its precedence is.

blocks|key|805022|text|Bjarne选择它们是因为它们的实用性、结合性和助记性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|805023|优先级并不完美，例如布尔运算符和位级运算符很麻烦。|805024|但这是相当不错的。|805025|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Bjarne chose them for practical precedence, associativity and mnemonic value.

The precedence isn't perfect, e.g. the boolean and bit-level operators are troublesome.

But it's fairly OK.

blocks|key|805082|text|插入运算符>>和<<分别与输入流和输出流一起使用，因为输入流意味着数据流入程序，而输出流意味着数据流出程序。由于这些插入操作符看起来像方向操作符(显示数据流的方向)，因此输入流选择>>，输出流选择<<。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|805083|看一下代码的一部分...|805084|int+Num1;
cin+>>+Num1;|code-block|syntax|javascript|805085|在这里，如果你仔细观察，>>会显示数据流到变量(在程序中声明)，这意味着数据流到程序，这是输入流的工作(这里是cin)。|805086|cout也是如此，|805087|int+Num2+=+5;
cout+<<+Num2;|805088|这里的<<显示了从程序流出的数据流(因为Num2是程序的一部分)，这是输出流的工作。|805089|我希望这一切对你来说是有意义的。|805090|entityMap^0|5|2|8|2|2I|2|2Q|2|0|0|0|C|2|1J|3|0|0|4|0|0|3|2|K|4|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1N|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|X|$]]

Insertion operator <code>&gt;&gt;</code> and <code>&lt;&lt;</code> are used with Input Stream and Output Stream respectively because Input stream 
means flow of data into your program and Output stream means flow of data out of your program. 
As these insertion operators look like Directional operator (Showing direction of flow of data), 
so <code>&gt;&gt;</code> is chosen for Input stream and <code>&lt;&lt;</code> for the Output stream. 

Have a look at the part of code...

<pre><code>int Num1;
cin &gt;&gt; Num1;
</code></pre>

here if you observe carefully <code>&gt;&gt;</code> is showing flow of data to variable (declared in program)
that means the flow of data to the program , which is a job of Input stream (here <code>cin</code>).

similarly goes with <code>cout</code>,

<pre><code>int Num2 = 5;
cout &lt;&lt; Num2;
</code></pre>

Here <code>&lt;&lt;</code> showing the flow of data out of the program (as <code>Num2</code> is part of the program), which is the job of Output stream.

I hope all this make sense to you.

blocks|key|1019283|text|cout+<<+"Output+sentence";+//+prints+Output+sentence+on+screen
cout+<<+120;+++++++++++++++//+prints+number+120+on+screen
cout+<<+x;+++++++++++++++++//+prints+the+content+of+x+on+screen+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1019284|<<运算符将它后面的数据插入到它前面的流中。在上面的示例中，它将常量字符串输出语句、数值常量120和变量x插入到标准输出流cout中。|unstyled|1019285|标准输入设备通常是键盘。在C%2B%2B中处理标准输入是通过在cin流上应用重载提取操作符(>>)来完成的。操作符后面必须跟一个变量，该变量将存储要从流中提取的数据。例如：|1019286|int+age;
cin+>>+age;|1019287|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>cout &lt;&lt; "Output sentence"; // prints Output sentence on screen
cout &lt;&lt; 120; // prints number 120 on screen
cout &lt;&lt; x; // prints the content of x on screen 
</code></pre>

The &lt;&lt; operator inserts the data that follows it into the stream preceding it. In the examples above it inserted the constant string Output sentence, the numerical constant 120 and variable x into the standard output stream cout.

The standard input device is usually the keyboard. Handling the standard input in C++ is done by applying the overloaded operator of extraction (>>) on the cin stream. The operator must be followed by the variable that will store the data that is going to be extracted from the stream. For example:

<pre><code>int age;
cin &gt;&gt; age;
</code></pre>

blocks|key|804828|text|我假设您已经知道C%2B%2B允许操作符重载。通常，只有在语义完全可转移的情况下才能重载操作符(例如，重载向量类的加法以将两个向量相加)。我认为你的问题指的是为什么要使用位移运算符，为iostream重载它们，并赋予它们与其原始目的完全不同的含义。之所以可以这样做，是因为位移位操作与iostream的操作相去甚远，因此没有人会被混淆，以为<<或>>正在对iostream进行位移位。它们使用方便的原因还在于，它们的顺序是先计算左边的操作数，然后计算右边的操作数，然后进行运算。当您使用运算符从iostream中追加或提取内容时，这符合您希望发生的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804829|但是，对于最初的问题，为什么？我真的不知道，在我看来，<<和>>似乎很容易理解为从一个实体获取信息并将其放入另一个实体中。为什么原因需要比这更复杂呢？使用它们看起来很明智，因为它们的含义是显而易见的。你还能向接线员提出更好的要求吗？|804830|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I assume that you are aware that C++ allows for operator overloading. In general, you overload operators only if the semantics are completely transferable (e.g. overloading the addition for a vector class to add two vectors together). I think your question refers to why one would use bitshift operators, overload them for the iostream, and give them a completely different meaning than their original purpose. The reason it can be done is because bitshift operations are so far removed from what iostreams do that no one could be confused into thinking that &lt;&lt; or >> is doing a bitshift on an iostream. And the reason why they are convenient to use also is that their ordering is to evaluate the operand on the left first, then the one on the right, and do the operation. This fits to what you would want to happen when you are using the operators to append or extract stuff from an iostream.

But, to the original question, why? I don't really know, it just seems to me like the &lt;&lt; and >> are pretty easily understood as taking information from one entity and putting it in the other. Why does the reason need to be more complicated than that? It looks sensible to use those because their meaning is obvious.. what better could you ask of an operator?

Question is in the title really; I'm sure there is something logical, but for now I'm stumped!

Why are bitwise shifts (<< and >>) used for cout and cin?

问题真的在标题中；我相信这是有逻辑的，但现在我被难住了！

问为什么按位移位(<<和>>)用于cout和cin？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么按位移位(<<和>>)用于cout和cin？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么按位移位(<<和>>)用于cout和cin？
EN