blocks|key|2814492|text|实际上，将首先评估%2B%2Bi。只有当它为false时，右侧才会被求值(在您的例子中不是)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2814493|"&&具有更高的优先级“这一事实与优先级(其操作数与之结合的程度)有关，而不是与”谁的操作数首先被计算“有关。|2814494|因为在表中&&确实在%7C%7C之上，所以表达式将被这样解释：|2814495|m+=+%2B%2Bi+%7C%7C+(%2B%2Bj+&&+%2B%2Bk)|code-block|syntax|javascript|2814496|entityMap^0|9|3|0|0|5|2|A|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

Actually <code>++i</code> will be evaluated first. Only if it's false will the right side be evaluated (and in your case it's not).

The fact that "&amp;&amp; has higher priority" relates to precedence (how tightly its operands stick to it) not "whose operands get evaluated first".

Because <code>&amp;&amp;</code> is indeed above <code>||</code> in the table, the expression will be interpreted like this:

<pre><code>m = ++i || (++j &amp;&amp; ++k)
</code></pre>

blocks|key|2814525|text|因为%7C%7C和&&+，因此指定|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2814526|注意:这最初也被标记为C%2B%2B，您在这里得到的答案略有不同，因为重载运算符%7C%7C或&&不要只缩短内置运算符|2814527|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|$]]

because || and &amp;&amp; <a href="http://en.wikipedia.org/wiki/Short_circuit_evaluation" rel="nofollow">short circuit</a> and therefore specify <a href="http://en.wikipedia.org/wiki/Sequence_point" rel="nofollow">sequence points</a>

Note: this was originally tagged C++ as well, and you get a slightly different answer there as overloaded operators || or &amp;&amp; do not short circuit just inbuilt ones

blocks|key|639700|text|基本上，%7C%7C的意思是，“如果你收到的东西是真的，就返回它，否则，就返回之后发生的任何事情。”所以，这里唯一要计算的就是m+=+(%2B%2Bi+!=+0)。这意味着“递增i，将m赋值给i的值，与0相比，break。”|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|639701|更具体地说，这是正在发生的事情：|639702|i+=+1;
i+=+i+%2B+1;
if(+i+)+{
+++m+=+1;
}
else+{+//+who+cares,+this+will+never+happen.
+++j+=+j+%2B+1;
+++if(+j+)+{
+++++++k+=+k+%2B+1;
+++++++m+=+(k+!=+0);+//+1
+++}
+++else+{
+++++++m+=+0;
+++}
}|code-block|syntax|javascript|639703|entityMap^0|4|2|1N|E|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Basically, <code>||</code> means, "if you have received something which is true, return that, otherwise, return whatever happens afterwards." So, the only thing which is evaluated there is <code>m = (++i != 0)</code>. That means "increment i, assign m to the value of i compared to 0, break."

To be more specific, this is what is happening:

<pre><code>i = 1;
i = i + 1;
if( i ) {
 m = 1;
}
else { // who cares, this will never happen.
 j = j + 1;
 if( j ) {
 k = k + 1;
 m = (k != 0); // 1
 }
 else {
 m = 0;
 }
}
</code></pre>

blocks|key|4712017|text|具有更高的优先级并不意味着它首先被评估。这只意味着它绑得更紧了。在该示例中，该表达式等同于：%2B%2Bi+%7C%7C+(%2B%2Bj+&&+%2B%2Bk)。首先计算的是%2B%2Bi，因为%7C%7C从左到右进行计算。只有当计算结果为false时，才会计算%2B%2Bj+&&+%2B%2Bk，因为%7C%7C是短路的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4712018|entityMap^0|1A|J|20|3|26|2|30|A|3D|2|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]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

Having higher precedence does not mean it gets evaluated first. It just means it binds tighter. In that example, that expression is equivalent to: <code>++i || (++j &amp;&amp; ++k)</code>. What gets evaluated first is <code>++i</code> because <code>||</code> evaluates left to right. Only if that evaluates to false will <code>++j &amp;&amp; ++k</code> be evaluated because <code>||</code> is short-circuiting.

blocks|key|4429209|text|Short+circuit+evaluation。如果&&的左侧为非零，则仅在此时才会计算右侧。同样，只有当%7C%7C的左侧为零时，才会计算右侧的值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4429210|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Short_circuit_evaluation^0|R|2|1I|2|0|O|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

<a href="http://en.wikipedia.org/wiki/Short_circuit_evaluation" rel="nofollow">Short circuit evaluation</a>. If, the left-side of the <code>&amp;&amp;</code> is non-zero, only then will the right-hand side be evaluated. Likewise, only if the left-hand side of the <code>||</code> is zero, will the right-hand side be evaluated.

blocks|key|4429239|text|快捷运算符将导致不计算不必要的表达式组件。由于&&具有更高的优先级，因此如果您希望在%2B%2Bi计算为true时允许%7C%7C运算符能够简化整个表达式，则需要最后计算它。在这种情况下，%2B%2Bi是"=“之后唯一计算的变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4429240|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Shortcut operators will cause the unnecessary expression components not to be evaluated. Since &amp;&amp; has a higher precedence, it would need to be evaluated last if you want to allow the || operator to be able to shortcut the whole expression when ++i evaluates to true. Since this is the case, ++i is the only variable evaluated after the "=".

blocks|key|2814705|text|“较高的运算符优先级”与“先评估”不同。使用短路运算符时，它们的计算顺序是从左到右。任何算术运算的结果都会受到运算符优先级的影响，但这不会改变短路的左-t0-右顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2814706|示例的复杂性是不做这类事情的一个很好的理由。即使您弄清楚了规则并确切地知道它将做什么，下一个来查看代码的程序员可能也不会。|2814707|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|$]]

"Higher operator precedence" is not the same as "evaluated first". When you use the short-circuiting operators, they are evaluated left-to-right. The results of any arithmetic will be affected by operator precedence, but that doesn't change the left-t0-right ordering of short circuiting.

The complexity of your example is a good reason for not doing this sort of thing. Even if you figure out the rules and know exactly what it will do, the next programmer to come along and look at the code probably won't.

blocks|key|4429302|text|您可以看到逻辑运算符在这里短路。如果%7C%7C条件的第一部分为真，则它永远不会计算表达式的其余部分(因为如果第一部分是指针非空检查，则不希望在第二部分中取消引用指针(如果指针为空))。此外，因为它在一个布尔结果表达式中，所以%2B%2Bi的结果在被赋值给bool之前被转换回1值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4429303|像避免瘟疫一样避免这种代码，它只会给你的调试带来短期和长期的噩梦。|4429304|entityMap^0|I|2|31|3|3C|4|3M|1|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|$]]

You're seeing logical operator short-circuiting here. If the first part of an <code>||</code> condition is true, then it never evaluates the rest of the expression (because if the first part is a pointer-not-null check you wouldn't want to dereference the pointer in the second part if it's null). Further, since it's in a boolean-result expression the result of <code>++i</code> is converted back to <code>bool</code> value <code>1</code> before being assigned into <code>m</code>.

Avoid this kind of code like the plague, it will only give you debugging nightmares in the short and long term.

blocks|key|4429327|text|优先级和评估顺序是两件不同的事情。%7C%7C和&&都从左到右计算它们的操作数；优先级不会改变这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4429328|给定表达式a+%7C%7C+b+&&+c，将首先计算a。如果结果为0，则将计算b+&&+c。|4429329|entityMap^0|H|2|K|2|0|5|B|M|1|Z|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

Precedence and order of evaluation are two different things. Both <code>||</code> and <code>&amp;&amp;</code> evaluate their operands left-to-right; precedence doesn't change that. 

Given the expression <code>a || b &amp;&amp; c</code>, <code>a</code> will be evaluated first. If the result is 0, then <code>b &amp;&amp; c</code> will be evaluated.

blocks|key|4429347|text|比较运算符(%7C%7C和&&)的顺序更为重要。这就是为什么你最好把你最重要的测试放在第一位。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4429348|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The order of comparison operators (|| and &amp;&amp;) is more important.
That's why you'd better placed your most important test first.

blocks|key|4429420|text|在C语言中，您需要注意两个不同的问题:运算符优先级和求值顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4429421|运算符优先级确定首先计算哪个运算符的操作数，以及哪些操作数属于哪个运算符。例如，在表达式a+%2B+b+*+c中，运算符*的优先级高于%2B。因此，该表达式的计算结果为|offset|length|style|CODE|4429422|a+%2B+(b+*+c)|4429423|C语言中的所有运算符都具有确定性优先级，并且它们在任何编译器上都是相同的。|4429424|计算顺序决定了哪个操作数首先被计算。请注意，子表达式也是一个操作数。在确定运算符优先级之后，将应用评估顺序。如果上面的a%2Bb*c示例具有从左到右的求值顺序，则操作数本身将按a、b、c的顺序进行求值。如果操作数是例如函数调用，则函数a()、b()和c()将按该顺序执行。本例中的所有操作数都需要求值，因为它们都被使用了。如果编译器可以确定某些操作数不需要求值，它就可以优化它们，而不管这些操作数是否包含副作用(例如函数调用)。|4429425|问题是操作数的计算顺序通常是未指定的行为，这意味着编译器可以自由地计算从左到右或从右到左的值，而我们不能知道或假设任何关于它的信息。这对于C中的大多数操作数都是正确的，除了少数例外，其中求值顺序始终是确定性的。这些是运算符%7C%7C+&&+?:+,的操作数，其中的求值顺序保证从左到右。(当使用正式的C语言语义时，有人说在计算左运算符和右运算符之间有一个序列点。)|4429426|4429427|因此，对于特定的示例m+=+%2B%2Bi+%7C%7C+%2B%2Bj+&&+%2B%2Bk。|4429428|4429429|一元前缀%2B%2B运算符具有最高的优先级，将运算符i，j和k绑定到它们。这个语法非常直观。|unordered-list-item|4429430|二元&&运算符的优先级是第二高的，它绑定了运算符%2B%2Bj和%2B%2Bk。因此，表达式等同于二元%7C%7C运算符具有第三高优先级，将运算符i%2B%2B和(j%2B%2B+&&+%2B%2Bk)=与其绑定。|4429431|赋值运算符=的优先级最低，将运算符m和%2B%2Bi+%7C%7C+(%2B%2Bj+&&+%2B%2Bk)与其绑定。|4429432|4429433|此外，我们可以看到，%7C%7C和&&运算符都在那些确保计算顺序从左到右的运算符中。换句话说，如果%7C%7C运算符的左操作数被计算为true，则编译器不需要计算右操作数。在特定示例中，%2B%2Bi始终为正，因此编译器可以执行相当大的优化，从而有效地将表达式重新生成为m+=+%2B%2Bi;|4429434|如果在编译时不知道i的值，编译器将被迫计算整个表达式。则表达式将按以下顺序求值：|4429435|4429436|&&的优先级高于%7C%7C，因此开始计算&&运算符。|4429437|+&&运算符的运算顺序保证从左到右，因此先执行%2B%2Bj。|4429438|如果%2B%2Bj的结果为true+(大于零)，并且只有这样，才计算右运算符:执行%2B%2Bk。|4429439|将%2B%2Bj+&&%2B%2Bk的结果存储在临时变量中。我在这里称它为j_and_k。如果%2B%2Bj和%2B%2Bk都为正，则j_and_k将包含值1+(true)，否则包含0(+false+)。|4429440|%7C%7C运算符保证操作数的求值顺序从左到右，因此首先执行%2B%2Bi。如果%2B%2Bi为false(零)，则执行|4429441|，然后才对右运算符"j_and_k“求值。如果其中一个或两个都为正，则%7C%7C运算符的结果为1+(true)，否则为0(False)。|4429442|m将根据结果获得值1或0。|4429443|4429444|entityMap^0|0|18|9|0|0|B|0|0|0|33|A|0|0|A|L|0|0|0|O|3|S|3|1P|3|1T|D|0|H|1|J|J|0|0|2D|3|3F|8|0|9|1|0|0|0|0|0|T|7|1F|7|0|0|A|7|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1O|8|@$D|1P|E|1Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1R|8|@$D|1S|E|1T|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1V|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1W|8|@$D|1X|E|1Y|F|G]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|20|8|@$D|21|E|22|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|T|3|U|5|V|7|24|8|@]|9|@]|A|$]]|$1|W|3|X|5|V|7|25|8|@$D|26|E|27|F|G]|$D|28|E|29|F|G]|$D|2A|E|2B|F|G]|$D|2C|E|2D|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|V|7|2E|8|@$D|2F|E|2G|F|G]|$D|2H|E|2I|F|G]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2K|8|@$D|2L|E|2M|F|G]|$D|2N|E|2O|F|G]]|9|@]|A|$]]|$1|13|3|14|5|6|7|2P|8|@$D|2Q|E|2R|F|G]]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]|$1|16|3|17|5|V|7|2T|8|@]|9|@]|A|$]]|$1|18|3|19|5|V|7|2U|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|V|7|2V|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|V|7|2W|8|@$D|2X|E|2Y|F|G]|$D|2Z|E|30|F|G]]|9|@]|A|$]]|$1|1E|3|1F|5|V|7|31|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|V|7|32|8|@$D|33|E|34|F|G]]|9|@]|A|$]]|$1|1I|3|1J|5|V|7|35|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|36|8|@]|9|@]|A|$]]|$1|1L|3|-4|5|6|7|37|8|@]|9|@]|A|$]]]|1M|$]]

In the C language, there are two different issues you need to be aware of: operator precedence and order of evaluation. 

Operator precedence determines which operator that gets its operands evaluated first, and also which operands that belong to which operator. For example in the expression <code>a + b * c</code>, the operator * has higher operator precedence than +. Therefore the expression will be evaluated as 

<code>a + (b * c)</code> 

All operators in the C language have deterministic precedence and they are the same on any compiler.

Order of evaluation determines which operand that gets evaluated first. Note that a sub-expression is also an operand. Order of evaluation is applied after the operator precedence has been determined. If the above a+b*c example has left-to-right order of evaluation, then the operands themselves get evaluated in the order a, b, c. If the operands were for example function calls, then the functions a(), b() and c() would have been executed in that order. All operands in this example need to be evaluated since they are all used. If the compiler can determine that some operands need not be evaluated, it can optimize them away, regardless of whether those operands contain side-effects (such as function calls) or not.

The problem is that order of evaluation of operands is most often unspecified behaviour, meaning that the compiler is free to evaluate either left-to-right or right-to-left, and we cannot know or assume anything about it. This is true for most operands in C, save for a few exceptions where the order of evaluation is always deterministic. Those are the operands of the operators <code>|| &amp;&amp; ?: ,</code>, where the order of evaluation is guaranteed to be left-to-right. (When using formal C language semantics, one says that there is a sequence point between the evaluation of the left and the right operator.)

<hr>

So for the specific example <code>m = ++i || ++j &amp;&amp; ++k</code>. 

<ul>
<li>The unary prefix ++ operators have the highest precedence, binding the operators i, j and k to them. This syntax is pretty intuitive.</li>
<li>The binary &amp;&amp; operator has 2nd highest precedence, binding the operators <code>++j</code> and <code>++k</code> to it. So the expression is equivalent to <code>m = ++i || (++j &amp;&amp; ++k)</code>.</li>
<li>The binary || operator has 3rd highest precedence, binding the operators <code>i++</code> and <code>(j++ &amp;&amp; ++k)=</code> to it.</li>
<li>The assignment operator = has the lowest precedence, binding the operators <code>m</code> and <code>++i || (++j &amp;&amp; ++k)</code> to it.</li>
</ul>

Further, we can see that both the || and the &amp;&amp; operators are among those operators where the order of evaluation is guaranteed to be left to right. In other words, if the left operand of the || operator is evaluated as true, the compiler does not need to evaluate the right operand. In the specific example, <code>++i</code> is always positive, so the compiler can perform quite an optimization, effectively remaking the expression to <code>m = ++i;</code>

If the value of <code>i</code> wasn't known at compile time, the compiler would have been forced to evaluate the whole expression. Then the expression would have been evaluated in this order:

<ul>
<li>&amp;&amp; has higher precedence than ||, so start evaluating the &amp;&amp; operator.</li>
<li>&amp;&amp; operator is guaranteed to have order of evaluation of operands left-to-right, so perform ++j first.</li>
<li>If the result of ++j is true (larger than zero), and only then, then evaluate the right operator: perform ++k.</li>
<li>Store the result of ++j &amp;&amp; ++k in a temporary variable. I'll call it <code>j_and_k</code> here. If both ++j and ++k were positive, then <code>j_and_k</code> will contain value 1 (true), otherwise 0 (false).</li>
<li>|| operator is guaranteed to have order of evaluation of operands left-to-right, so perform ++i first.</li>
<li>If ++i is false (zero), and only then, evaluate the right operator "<code>j_and_k</code>". If one or both of them are positive, the result of the || operator is 1 (true), otherwise it is 0 (false).</li>
<li>m gets assigned the value 1 or 0 depending on the result.</li>
</ul>

I came across this code:

<pre><code> int main()
 {
 int i=1,j=2,k=0,m=0;
 m = ++i || ++j &amp;&amp; ++k;
 printf("%d %d %d %d %d",i,j,k,m);
 }
</code></pre>

The program returns <code>2 2 0 1...</code>. Why?

<code>&amp;&amp;</code> has a higher priority than <code>||</code> so <code>++j &amp;&amp; ++k</code> should be evaluated first. Hence I would expect <code>j=3</code> and <code>k=1</code>. It will return true hence <code>||</code> becomes true so <code>++i</code> shouldn't be evaluated. But it works other way around.

I would like others to explain to me.

&& and || operators

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我偶然发现了这段代码：    int main()    {        int i=1,j=2,k=0,m=0;        m = ++i || ++j && ++k;        printf("%d %d %d %d %d",i,j,k,m);    }程序返回2 2 0 1...。为什么？&&的优先级高...

问&&和||运算符
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问&&和||运算符EN