blocks|key|2571647|text|你必须用括号把一个三元运算括起来：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2571648|std::cout+<<+((abs(c2-c1)+==+abs(r2-r1))+?+1+:+2)+<<+std::endl;|code-block|syntax|javascript|2571649|如果没有，<<操作符将转到2，它会给出一个错误，因为它没有这样的重载函数。|offset|length|style|CODE|2571650|这是因为逐位左移运算符(<<)的优先级高于三元运算符。您可以在this+page+of+the+C%2B%2B+reference中查看运算符及其优先级的完整列表。|2571651|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/operator_precedence^0|0|0|5|2|D|1|0|C|2|V|U|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@$I|14|J|15|K|L]]|9|@$I|16|J|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

You have to put parentheses around a ternary operation:

<pre><code>std::cout &lt;&lt; ((abs(c2-c1) == abs(r2-r1)) ? 1 : 2) &lt;&lt; std::endl;
</code></pre>

If not the the <code>&lt;&lt;</code> operator goes to the <code>2</code> and it gives an error because it doesn't have such overloaded function.

This happens because the bitwise left shift operator (<code>&lt;&lt;</code>) has a higher precedence than the ternary operator. You can see the full list of operators and their precedence in <a href="https://en.cppreference.com/w/cpp/language/operator_precedence" rel="nofollow noreferrer">this page of the C++ reference</a>.

blocks|key|2783779|text|这与返回类型是如何推导的无关，而是与operator+precedence有关。当你有了|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2783780|std::cout+<<+(abs(c2-c1)+==+abs(r2-r1))+?+1+:+2+<<+std::endl;|code-block|syntax|javascript|2783781|它不是|2783782|std::cout+<<+((abs(c2-c1)+==+abs(r2-r1))+?+1+:+2)+<<+std::endl;|2783783|因为?:的优先级比<<低。这意味着你实际拥有的是|style|CODE|2783784|(std::cout+<<+(abs(c2-c1)+==+abs(r2-r1)))+?+1+:+(2+<<+std::endl);|2783785|这就是为什么你会得到一个关于<unresolved+overloaded+function+type>的错误。只需使用括号，如|2783786|std::cout+<<+((abs(c2-c1)+==+abs(r2-r1))+?+1+:+2)+<<+std::endl;|2783787|你会好起来的。|2783788|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/operator_precedence^0|I|J|0|0|0|0|0|2|2|9|2|0|0|E|11|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1D|8|@$A|1E|B|1F|O|P]|$A|1G|B|1H|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1I|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1J|8|@$A|1K|B|1L|O|P]]|9|@]|C|$]]|$1|U|3|V|5|F|7|1M|8|@]|9|@]|C|$G|H]]|$1|W|3|X|5|6|7|1N|8|@]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]]]

This has nothing to do with how the return type is deduced and everything to do with <a href="https://en.cppreference.com/w/cpp/language/operator_precedence" rel="noreferrer">operator precedence</a>. When you have

<pre><code>std::cout &lt;&lt; (abs(c2-c1) == abs(r2-r1)) ? 1 : 2 &lt;&lt; std::endl;
</code></pre>

it isn't

<pre><code>std::cout &lt;&lt; ((abs(c2-c1) == abs(r2-r1)) ? 1 : 2) &lt;&lt; std::endl;
</code></pre>

because <code>?:</code> has lower precedence than <code>&lt;&lt;</code>. That means what you actually have is

<pre><code>(std::cout &lt;&lt; (abs(c2-c1) == abs(r2-r1))) ? 1 : (2 &lt;&lt; std::endl);
</code></pre>

and this is why you get an error about an <code>&lt;unresolved overloaded function type&gt;</code>. Just use parentheses like 

<pre><code>std::cout &lt;&lt; ((abs(c2-c1) == abs(r2-r1)) ? 1 : 2) &lt;&lt; std::endl;
</code></pre>

and you'll be okay.

blocks|key|2571746|text|由于使用了operator+precedence，该行被视为：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2571747|(std::cout+<<+(abs(c2-c1)+==+abs(r2-r1)))+?+1+:+(2+<<+std::endl);|code-block|syntax|javascript|2571748|将其更改为|2571749|std::cout+<<+((abs(c2-c1)+==+abs(r2-r1))+?+1+:+2)+<<+std::endl;
//+++++++++++%5E----------------------------------%5E
//+++++++++++Surrounding+parentheses|2571750|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/language/operator_precedence^0|5|J|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Due to <a href="http://en.cppreference.com/w/cpp/language/operator_precedence" rel="nofollow noreferrer">operator precedence</a>, that line is treated as:

<pre><code>(std::cout &lt;&lt; (abs(c2-c1) == abs(r2-r1))) ? 1 : (2 &lt;&lt; std::endl);
</code></pre>

Change it to

<pre><code>std::cout &lt;&lt; ((abs(c2-c1) == abs(r2-r1)) ? 1 : 2) &lt;&lt; std::endl;
// ^----------------------------------^
// Surrounding parentheses
</code></pre>

blocks|key|69044|text|当解析顺序可视化时，很容易看到错误：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|69045|std::cout+<<+(abs(c2-c1)+==+abs(r2-r1))+?+1+:+2+<<+std::endl;
\_______/++++++++++++++++++++++++++++++++++++++++++++++++++++++<---+#1
+++++++++++++\________________________/+++V+++\~~~~error~~~/+++<---+#2
+++++++++++++\_____________________________________________/+++<---+#3
\__________________________________________________________/+++<---+#4
\___________________________________________________________/++<---+#5|code-block|syntax|javascript|69046|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It's easy to see the mistake when the parsing order is visualized:

<pre><code>std::cout &lt;&lt; (abs(c2-c1) == abs(r2-r1)) ? 1 : 2 &lt;&lt; std::endl;
\_______/ &lt;--- #1
 \________________________/ V \~~~~error~~~/ &lt;--- #2
 \_____________________________________________/ &lt;--- #3
\__________________________________________________________/ &lt;--- #4
\___________________________________________________________/ &lt;--- #5
</code></pre>

blocks|key|2571822|text|您提出的问题的字面答案是[expr.cond]+secton+of+the+C%2B%2B+language+standard.中的算法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2571823|基本规则“确定是否可以形成从第二个操作数到为第三个操作数确定的目标类型的隐式转换序列，反之亦然。如果没有一个可能的转换，或者有多个转换，这是一个语法错误，但有几种特殊情况(这里不适用)：|2571824|2571825|如果两者都是算术类型或代码类型，则对确定表达式类型的enum进行相同类型的隐式转换，例如目标的a+%2B+b或throw可以是throw表达式，并被视为具有另一个的类型。|unordered-list-item|style|CODE|2571826|如果其中一个目标是位域，则具有不同限定符(如const和D15)的条件代码的类型也是相同的，它们的限定符是统一的。H216F217|2571827|2571828|如果目标是相同类型的glvalue，则结果是glvalue，否则是prvalue。|2571829|当有疑问时，您总是可以显式强制转换一个或两个操作数，以便它们具有相同的类型。|2571830|您在这里的实际问题是运算符优先级，正如公认的答案所解释的那样。也就是说，编译器将第三个操作数解析为2+<<+std::endl，而不是2。|2571831|entityMap|0|LINK|mutability|MUTABLE|url|http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2017/n4659.pdf#section.8.16^0|C|1C|0|0|0|0|Q|4|1B|5|1H|5|1P|5|0|M|5|0|0|0|0|1D|E|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|17|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|18|8|@$A|19|B|1A|J|K]|$A|1B|B|1C|J|K]|$A|1D|B|1E|J|K]|$A|1F|B|1G|J|K]]|9|@]|C|$]]|$1|L|3|M|5|I|7|1H|8|@$A|1I|B|1J|J|K]]|9|@]|C|$]]|$1|N|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1L|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1M|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1N|8|@$A|1O|B|1P|J|K]]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

The literal answer to the question you asked is the algorithm in the <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2017/n4659.pdf#section.8.16" rel="nofollow noreferrer">[expr.cond] secton of the C++ language standard.</a>

The basic rule “determined whether an implicit conversion sequence can be formed from the second operand to the target type determined for the third operand, and vice versa.” If there isn’t one possible conversion, or there is more than one, it’s a syntax error, but there are several special cases (which don’t apply here):

<ul>
<li>If both are arithmetic or <code>enum</code> types, you get the same kind of implicit conversion for <code>p ? a : b</code> that determines the type of an expression such as <code>a + b</code> or <code>a * b</code>.</li>
<li>One of the targets may be a <code>throw</code> expression, and is treated as having the type of the other.</li>
<li>If one of the targets is a bitfield, so is the type of the conditional expression</li>
<li>Pointers with different qualifiers (such as <code>const</code> and <code>volatile</code>) have their qualifiers unified.</li>
</ul>

The result is a glvalue if the targets are glvalues of the same type, and a prvalue otherwise.

When in doubt, you can always explicitly cast one or both of the operands so that they have the same type.

Your actual problem here is operator precedence, as the accepted answer explains. That is, the compiler parses the third operand as <code>2 &lt;&lt; std::endl</code>, rather than 2.

blocks|key|70491|text|根据cppreference的说法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|70492|70493|解析表达式时，上表中具有优先级的某一行中列出的运算符将与其参数绑定得更紧密(就像通过圆括号一样)，而不是在其下方具有较低优先级的行中列出的任何运算符。例如，表达式std::cout+<<+a+&+b和*p%2B%2B被解析为(std::cout+<<+a)+&+b和*(p%2B%2B)，而不是std::cout+<<+(a+&+b)或(*p)%2B%2B。|blockquote|style|CODE|70494|70495|具有相同优先级的运算符在它们的结合性方向上绑定到它们的参数。|70496|请注意，结合性对于成员访问操作符是有意义的，即使它们是用一元后缀运算符分组的：a.b%2B%2B被解析为(a.b)%2B%2B而不是a.(b%2B%2B)。|70497|例如，std::cout+<<+a+?+b+:+c;解析为(std::cout+<<+a)+?+b+:+c;，因为算术左移的优先级高于条件运算符。|70498|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/operator_precedence^0|2|C|0|0|0|29|I|2S|4|30|K|3L|6|3V|K|4G|6|0|0|0|13|5|1C|7|1M|7|0|3|N|T|P|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|13|8|@$A|14|B|15|H|I]|$A|16|B|17|H|I]|$A|18|B|19|H|I]|$A|1A|B|1B|H|I]|$A|1C|B|1D|H|I]|$A|1E|B|1F|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1H|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1I|8|@$A|1J|B|1K|H|I]|$A|1L|B|1M|H|I]|$A|1N|B|1O|H|I]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1P|8|@$A|1Q|B|1R|H|I]|$A|1S|B|1T|H|I]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1U|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

According to <a href="https://en.cppreference.com/w/cpp/language/operator_precedence" rel="nofollow noreferrer">cppreference</a>:
<blockquote>
When parsing an expression, an operator which is listed on some row of the table above with a precedence will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it with a lower precedence. For example, the expressions <code>std::cout &lt;&lt; a &amp; b</code> and <code>*p++</code> are parsed as <code>(std::cout &lt;&lt; a) &amp; b</code> and <code>*(p++)</code>, and not as <code>std::cout &lt;&lt; (a &amp; b)</code> or <code>(*p)++</code>.
Operators that have the same precedence are bound to their arguments in the direction of their associativity. For example, the expression <code>a = b = c</code> is parsed as <code>a = (b = c)</code>, and not as <code>(a = b) = c</code> because of right-to-left associativity of assignment, but <code>a + b - c</code> is parsed <code>(a + b) - c</code> and not <code>a + (b - c)</code> because of left-to-right associativity of addition and subtraction.
Associativity specification is redundant for unary operators and is only shown for completeness: unary prefix operators always associate right-to-left (<code>delete ++*p</code> is <code>delete (++(*p)))</code> and unary postfix operators always associate left-to-right (<code>a[1][2]++</code> is <code>((a[1])[2])++</code>). Note that the associativity is meaningful for member access operators, even though they are grouped with unary postfix operators: <code>a.b++</code> is parsed <code>(a.b)++</code> and not <code>a.(b++)</code>.
Operator precedence is unaffected by operator overloading. For example, <code>std::cout &lt;&lt; a ? b : c;</code> parses as <code>(std::cout &lt;&lt; a) ? b : c;</code> because the precedence of arithmetic left shift is higher than the conditional operator.
</blockquote>

I was solving a problem about movement of a bishop on a chessboard. At one point of my code, I had the following statement:

<pre class="lang-cpp prettyprint-override"><code>std::cout &lt;&lt; (abs(c2-c1) == abs(r2-r1)) ? 1 : 2 &lt;&lt; std::endl;
</code></pre>

This generates the following error:

<blockquote>
<pre><code>error: invalid operands of types 'int' and '&lt;unresolved overloaded function type&gt;' to binary 'operator&lt;&lt;'
</code></pre>
</blockquote>

However, I instantaneously fixed this error by including an additional variable in my code:

<pre class="lang-cpp prettyprint-override"><code>int steps = (abs(c2-c1) == abs(r2-r1)) ? 1 : 2;
std::cout &lt;&lt; steps &lt;&lt; std::endl;
</code></pre>

How does the ternary operator work, and how is its return type determined (as the compiler called it <code>&lt;unresolved overloaded function type&gt;</code>)?

How is the return type of a ternary operator determined?

编译器

我正在解决一个关于棋盘上一位主教移动的问题。在我的代码中，我有以下语句：std::cout << (abs(c2-c1) == abs(r2-r1)) ? 1 : 2 << std::endl;这将生成以下错误：错误:二进制'operator<<‘的类型'int’和'‘的操作数无效但是，我在代码中添加了一个额外的变量，...

问三元运算符的返回类型是如何确定的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问三元运算符的返回类型是如何确定的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问三元运算符的返回类型是如何确定的？
EN