blocks|key|2120818|text|那么，表达式c+==+2将返回true，因此将b与true而不是2进行比较。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2120819|编辑:它很可能是这样实现的，因为这就是C风格的语言处理布尔表达式的方式。他们必须为多个术语创建一个特殊的异常，并以不同的方式实现它，而使用赋值运算符则更简单:最右侧的表达式计算为一个值，该值可以逻辑上应用于链中的下一个表达式。看起来设计师采用了简单的方法。|2120820|entityMap^0|6|6|F|4|N|1|P|4|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|$]]

Well, the expression <code>c == 2</code> would return <code>true</code>, so then <code>b</code> would be being compared to <code>true</code> rather than 2.

Edit: It was most likely implemented this way as that's how C-style languages handle boolean expressions. They'd have to make a special exception for multiple terms and implement it differently whereas with the assignment operator it's more straightforward: the right most expression evaluates to a value that can logically be applied to the next expression in the chain. Seems the designers took the simple approach.

blocks|key|579091|text|不是对你的问题的直接回答，但如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|579092|bool+allTwo+=+a+&+b+&+c+==+2;|code-block|syntax|javascript|579093|编辑:正如Pete所说，这是行不通的。这个怎么样？|579094|bool+allEqual(params+int[]+inputs)
{
++++int+lastval+=+inputs[0];
++++for+(int+i+=+1;+i+<+inputs.length;+i%2B%2B)
++++{
++++++++if+(lastval+!=+inputs[i])
++++++++++++return+false;

++++++++lastval+=+inputs[i];
++++}

++++return+true;
}|579095|声明它一次，在需要的时候使用它，用逗号分隔的整数列表进行比较。(它可能还有一个更简单的函数，不过无所谓。)|579096|bool+allTwo+=+a+==+b+&&+b+==+c+&&+c+==+2;+//+prefer+this+format+over+a+==+2+&&+b+==+2+&&+c+==+2,+personally|579097|对比|579098|bool+allTwo+=+allEqual(a,+b,+c,+2);|579099|对于你的问题本身，我没有太多要说的，其他人的回答中已经说过了。|579100|entityMap^0|0|0|0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Not a direct answer to your question, but how about:

<pre><code>bool allTwo = a &amp; b &amp; c == 2;
</code></pre>

EDIT: As Pete says, that wouldn't work. How's this?

<pre><code>bool allEqual(params int[] inputs)
{
 int lastval = inputs[0];
 for (int i = 1; i &lt; inputs.length; i++)
 {
 if (lastval != inputs[i])
 return false;

 lastval = inputs[i];
 }

 return true;
}
</code></pre>

Declare it once, use it whenever you want with a comma-separated list of integers to compare. (There's probably an even simpler function for it, but whatever.)

<pre><code>bool allTwo = a == b &amp;&amp; b == c &amp;&amp; c == 2; // prefer this format over a == 2 &amp;&amp; b == 2 &amp;&amp; c == 2, personally
</code></pre>

versus

<pre><code>bool allTwo = allEqual(a, b, c, 2);
</code></pre>

There's not really much for me to say in regards to your question itself that hasn't already been said in the answers of others.

blocks|key|577871|text|表达式a+==+b的类型是boolean，因此您要么必须打破表达式的含义与上下文相同的规则，要么使用n元==运算符，以便将a+==+b+==+c解析为(==+a+b+c)而不是(==+(==+a+b)+c)。这意味着您需要使用(a+==+b)+==+c将布尔值c与(a+==+b)的结果进行比较，这是可以的，但不是C#传统中的简单C风格的语法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|577872|entityMap^0|3|6|1P|B|23|A|2G|F|35|D|3O|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|G|$]]

The type of the expression <code>a == b</code> is boolean, so you would either have to break a rule that an expression means the same thing whatever its context, or have n-ary == operators so that <code>a == b == c</code> is parsed as <code>(== a b c)</code> rather than <code>(== (== a b) c)</code>. Which then means you need to have <code>(a == b) == c</code> to compare the boolean c to the result of <code>(a == b)</code>, which is OK, but not the simple C style of grammar which C# is in the tradition of.

blocks|key|2120936|text|要做你想做的事情，operator+==应该返回object。在这种情况下，我们将遇到另一个问题--现在我们需要将任何对象隐式转换为布尔值。这样的转换也会产生额外的问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2120937|entityMap^0|9|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

To do what you want, <code>operator ==</code> should return object. In this case, we will have another problem - now we need an implicit conversion of any object to boolean. Such a conversion will also create extra problems.

blocks|key|2120999|text|我找不到引文，但我想是Eric+Lippert+(?)谁说得最好:不实现一个功能是免费的。另请参阅http://blog.ryjones.org/2005/07/12/product-development/和http://blog.ryjones.org/2005/07/12/product-development/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2121000|他们有许多功能要实现，我无法想象像这样价值可疑的非标准功能会是一个高优先级的东西。我不是说它不值钱，但它可能会导致混乱，可能不会经常使用，等等。我认为a1ex07也有一个很好的观点。这必须是一个自定义案例，因为它不能再被通用地处理了(==总是返回boolean，等等)。|2121001|你现在可以用LINQ做同样的事情，但是语法有点复杂，它需要分配某种类型的数组：|2121002|bool+allTwo+=+new+int[]+{+a,+b,+c+}.All(i+=>+i+==+2);|code-block|syntax|javascript|2121003|你可以倒着做，看看有没有!=+2：|2121004|bool+allNotTwo+=+new+int[]+{+a,+b,+c+}.Any(i+=>+i+!=+2);|2121005|在这两种情况下，它也会在其中一个无效时立即退出，因此您通常不会遍历整个列表。|2121006|编辑：这里还有一点：Does+C#+have+too+many+language+features?|style|BOLD|2121007|一些新的东西已经成为非常有用的语言，使其成为|2121008|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.ryjones.org/2005/07/12/product-development/|1|2|https://stackoverflow.com/questions/797014/does-c-have-too-many-language-features^0|1D|1J|0|2X|1J|1|0|0|0|0|0|0|0|0|3|A|14|2|0|A|C|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]|$A|1D|B|1E|1|1F]]|C|$]]|$1|D|3|E|5|6|7|1G|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1H|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1I|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1J|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1K|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1M|8|@$A|1N|B|1O|U|V]]|9|@$A|1P|B|1Q|1|1R]]|C|$]]|$1|W|3|X|5|6|7|1S|8|@$A|1T|B|1U|U|V]]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|15]]|17|$5|11|12|13|C|$14|18]]]]

I can't find the quote, but I think it was Eric Lippert (?) who put it best: not implementing a feature is free. See also <a href="http://blog.ryjones.org/2005/07/12/product-development/" rel="nofollow noreferrer">http://blog.ryjones.org/2005/07/12/product-development/</a> and <a href="http://blog.ryjones.org/2005/07/12/product-development/" rel="nofollow noreferrer">http://blog.ryjones.org/2005/07/12/product-development/</a>

They have many features to implement and I can't imagine something non-standard like this with questionable value would be a high priority. I'm not saying it's not valuable, but it could lead to confusion, probably wouldn't be used very often, etc. I think a1ex07 has a good point too. This would have to be a custom case since it can't really be handled generically anymore (== always returns boolean, etc.)

You can do the same thing now with LINQ, but the syntax is a bit more convoluted and it requires allocating an array of some sort:

<pre><code>bool allTwo = new int[] { a, b, c }.All(i =&gt; i == 2);
</code></pre>

You can do it backwards and check if any != 2:

<pre><code>bool allNotTwo = new int[] { a, b, c }.Any(i =&gt; i != 2);
</code></pre>

In both of these cases it will also quit as soon as one is invalid, so you often won't go through the whole list.

Edit: Here's another point: <a href="https://stackoverflow.com/questions/797014/does-c-have-too-many-language-features">Does C# have too many language features?</a>

<blockquote>
 something new has be be very useful to
 make it into the language
</blockquote>

blocks|key|2121063|text|我认为你的问题在你的参考点上有所恶化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2121064|a+=+b+=+c+=+2并没有什么神奇之处来建议a+==+b+==+c+==+2应该按照您想要的方式工作--实际上更多--所以恰恰相反。|offset|length|style|CODE|2121065|赋值运算符仅为2个操作数定义，并返回所设置的值。它们中的一个字符串只是将值从每个运算符传递到下一个运算符：|2121066|1:+a+=+(b+=+(c+=+2));
2:+a+=+(b+=+(2));
3:+a+=+(2);|code-block|syntax|javascript|2121067|因此，a+==+b+==+c+==+2也是如此|2121068|1:+bool+allTwo+=+(a+==+(b+==+(c+==+2)));
2:+bool+allTwo+=+(a+==+(b+==+([Boolean])));
3:+bool+allTwo+=+(a+==+([Boolean]));
4:+bool+allTwo+=+([Boolean]);|2121069|因此，技术原因很简单，因为C#没有包含对运算符字符串进行特殊处理的定义。|2121070|至于语言的设计和实现，原因可能是为了防止歧义和额外的复杂性。虽然您现在可能希望将a+==+b+==+c+==+2定义为all+equal运算符，但在下一行中，您很可能需要它按照当前实现的方式运行。应该如何区分这些行为？它是否真的值得努力去实现呢？|BOLD|2121071|或者a+==+2+&&+b+==+2真的那么糟糕？;)|2121072|entityMap^0|0|0|D|P|G|0|0|0|3|G|0|0|D|2|0|14|G|1N|9|0|2|G|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|17|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|18|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1C|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1D|8|@$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1G|8|@$D|1H|E|1I|F|G]|$D|1J|E|1K|F|W]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1L|8|@$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|10|$]]

I think you're question somewhat deteriorates at your point of reference.

There's nothing magic about <code>a = b = c = 2</code> to suggest that <code>a == b == c == 2</code> should work like you're wanting -- actually more-so the opposite.

The assignment operator is defined for only 2 operands and returns the value being set. A string of them simply passes the value from each operator to the next:

<pre><code>1: a = (b = (c = 2));
2: a = (b = (2));
3: a = (2);
</code></pre>

So, the same is true for <code>a == b == c == 2</code>:

<pre><code>1: bool allTwo = (a == (b == (c == 2)));
2: bool allTwo = (a == (b == ([Boolean])));
3: bool allTwo = (a == ([Boolean]));
4: bool allTwo = ([Boolean]);
</code></pre>

So, the technical reason is simply that <code>C#</code> doesn't contain a definition to have special treatment for a string of operators.

As for language design and implementation, the reason would probably be to prevent ambiguity and additional complexity. While you may want <code>a == b == c == 2</code> defined as an all equal operator now, on the next line you may very well need it to act as currently implemented. How should the behaviors be distinguished? And would it be truly worth the effort to implement?

Or is <code>a == 2 &amp;&amp; b == 2</code> really that bad? ;)

blocks|key|2121130|text|从我的角度来看，这是一个清晰的问题。如果由我决定，我会考虑添加这样的语言功能可能会增加太多关于如何计算复杂表达式的歧义。A+==+b+==+c和(a+==+b)+==+c在某些情况下是不同的吗？如果我真的想将c与==+b的布尔结果进行比较，而不是将c与b进行比较，该怎么办？在大多数情况下，编译器可能会找出正确的比较，但如果c是隐式转换为bool的，尽管可能性不大，那么可能无法判断。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2121131|因此，就我个人而言，我不确定是否值得这么麻烦。虽然它在语法上可能看起来不是很好，但您可以构建自己的实用函数来比较多个对象的相等性，如下所示：|2121132|++++public+static+bool+Equals(this+object+x,+params+object[]+y)
++++{
++++++++for+(int+i+=+0;+i+<+y.Length;+i%2B%2B)
++++++++{
++++++++++++if+(!object.Equals(x,+y[i]))
++++++++++++++++return+false;
++++++++}
++++++++return+true;
++++}|code-block|syntax|javascript|2121133|然后你可以像这样使用它：|2121134|++++++++if+(a.Equals(b,+c,+d,+e,+f,+g))
++++++++{
++++++++++++//+...
++++++++}|2121135|entityMap^0|0|0|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|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

From my perspective it's a question of clarity. If the decision were up to me, I would consider how adding such a language feature might add too much ambiguity regarding how complicated expressions are evaluated. Is a == b == c different from (a == b) == c in certain situations? What if I really want to compare c to the Boolean result of a == b rather than compare c to b? In most cases the compiler can probably figure out the proper comparison, but if c is implicitly convertible to bool, though unlikely, then it might be impossible to tell.

So personally, I'm not sure it's worth the hassle. While it may not look as nice syntactically, you could build your own utility function to compare equality of multiple objects, such as below:

<pre><code> public static bool Equals(this object x, params object[] y)
 {
 for (int i = 0; i &lt; y.Length; i++)
 {
 if (!object.Equals(x, y[i]))
 return false;
 }
 return true;
 }
</code></pre>

Then you could use it like this:

<pre><code> if (a.Equals(b, c, d, e, f, g))
 {
 // ...
 }
</code></pre>

blocks|key|2121199|text|忽略返回值，这也与operator+associativity有关。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2121200|赋值运算符是右关联的。也就是说，首先计算赋值运算符的右侧。这就是为什么你可以执行a+=+b+=+c+=+2，并将它们都赋值为2，否则，你最终会得到a的旧值b和b的旧值c。|style|CODE|2121201|大多数其他运算符是左关联的，特别是短路逻辑运算符(&&和%7C%7C)。也就是说，a+==+b或a+&&+b首先计算a。|2121202|你可以争辩说，==可能是右联想的。除了在.NET中它不能，因为对于对象，a+==+b+(除非被覆盖)被转换为a.Equals(b)+(或者是a.ReferenceEquals(b)...我从来不记得)。|2121203|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Operator_associativity^0|9|M|0|0|14|D|21|1|25|1|27|1|2B|1|0|P|2|S|2|11|6|18|6|1I|1|0|7|2|10|6|1I|B|1Y|K|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@$A|Y|B|Z|F|G]|$A|10|B|11|F|G]|$A|12|B|13|F|G]|$A|14|B|15|F|G]|$A|16|B|17|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|18|8|@$A|19|B|1A|F|G]|$A|1B|B|1C|F|G]|$A|1D|B|1E|F|G]|$A|1F|B|1G|F|G]|$A|1H|B|1I|F|G]]|9|@]|C|$]]|$1|J|3|K|5|6|7|1J|8|@$A|1K|B|1L|F|G]|$A|1M|B|1N|F|G]|$A|1O|B|1P|F|G]|$A|1Q|B|1R|F|G]]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

Ignoring return values, it also has to do with <a href="http://en.wikipedia.org/wiki/Operator_associativity" rel="nofollow noreferrer">operator associativity</a>.

Assignment operators are right-associative. That is to say that the right side of an assignment operator is evaluated first. This is why you can do <code>a = b = c = 2</code> and have them all assigned the value 2. Otherwise, you'd end up with <code>a</code> having the old value of <code>b</code> and <code>b</code> having the old value of <code>c</code>.

Most other operators are left-associative, particularly the short-circuit logic operators (<code>&amp;&amp;</code> and <code>||</code>). That is to say that <code>a == b</code> or <code>a &amp;&amp; b</code> evaluates <code>a</code> first.

You could argue that <code>==</code> could be right-associative... except that in .NET it can't, because for objects, <code>a == b</code> is (unless overridden) converted to <code>a.Equals(b)</code> (or is that <code>a.ReferenceEquals(b)</code>... I never remember).

Given that it's valid to write

<pre><code>a = b = c = 2;
</code></pre>

It would also be nice, rather than 

<pre><code>bool allTwo = a == 2 &amp;&amp; b == 2 &amp;&amp; c == 2;
</code></pre>

to instead write

<pre><code>bool allTwo = a == b == c == 2;
</code></pre>

But I can't since a == b evaluates to a boolean which can't then be compared to an integer.

Is there a language-design reason it has been implemented this way?

boolean expressions, why just two terms?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设它是有效的，所以可以这样写a = b = c = 2;它也会很好，而不是bool allTwo = a == 2 && b == 2 && c == 2;改为写bool allTwo = a == b == c == 2;但我不能，因为== b的计算结果是布尔值，而布尔值不能与整数进行比较。有没有语言设计的原因，它...

问布尔表达式，为什么只有两项？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问布尔表达式，为什么只有两项？EN