&& 的哪一侧（左或右） (and) 运算符在 C++ 中计算

Question

and && 的顺序是？ 例如，

以下代码

if (float alpha = value1-value2 && alpha > 0.001)
    //do something

引发了一个异常，即 alpha 正在使用但未启动。 我认为 && 左边的表达式是总是会首先启动 alpha 的值，但看来我可能是错的

有什么想法吗？

谢谢

Answer 1

这被解析为：

if (int alpha = (value1-value2 && (alpha > 0.001)))

... 因为 && 具有比 = 更高的“解析优先级”——这可能不是您想要的。尝试：

int alpha = value1-value2; 
if (alpha && (alpha > 0.001))

Answer 2

这里的底线是，您试图表达的内容不可能通过嵌入了 alpha 声明的单个逻辑条件来表达（尽管其他一些答案声称如此）。

其他答案已经向您解释了您的条件并未按照您认为的解析方式进行解析，尽管许多答案在引用条件中 = 运算符的优先级时犯了明显的错误，而实际上那里没有任何 = 运算符。正确的解释是，当您在 if 条件中声明变量时，语法是带有初始值设定项的声明的语法，因此整个事物的解析方式与

int alpha = value1 - value2 && alpha > 0.001;

解析方式相同，即它是一个使用 value1 - value2 && 初始化的 int alpha 声明阿尔法> 0.001 。其中没有运算符 = 。我希望现在您可以明白为什么编译器说您正在初始化表达式中读取未初始化的变量。 编译器也会对以下声明提出同样的抱怨

int alpha = alpha; // reading uninitialized variable

出于同样的原因，

。为了实现您想要表达的内容，您必须预先声明 alpha

int alpha;
if ((alpha = value1 - value2) && alpha > 0.001) {
  // whatever 
}

或将您的 if 分成两个

if (int alpha = value1 - value2) 
  if (alpha > 0.001) {
    // whatever 
  }

但是，由于第二个条件已经要求 alpha 大于 0，即使验证第一个也没有多大意义，所以最有意义的事情就是减少当然

int alpha = value1 - value2;
if (alpha > 0.001) {
  // whatever 
}

，正如其他人已经指出的那样，将 int 值与 0.001 进行比较是有效的，但相当奇怪。只要做

int alpha = value1 - value2;
if (alpha > 0) {
  // whatever 
}

Answer 3

始终首先评估左侧。这里的问题是运算符优先级。看看这样是否效果更好：

if ((int alpha = value1-value2) && (alpha > 0.001))

Answer 4

在澄清其工作原理（出于教育目的）后，不要这样做。不要在同一语句中混合变量初始化/赋值和比较。

如果每个语句单独是一个“命令”或一个“查询”，那就更好了。

如果“if”中的条件非常清晰易读并且明确是布尔值，那就好多了。不是整数，什么也没有，只是布尔值。

条件的第一部分是一个整数。然后你用 bool 来执行 and 操作。您完全没有必要强制进行转换。 准确地给出 if 和条件运算符的要求：布尔值。

Answer 5

回答标题中的问题，取决于操作数的类型。

对于内置类型，&& 短路，意味着计算 LHS，如果为 false，则根本不计算 RHS。

对于重载operator&&的用户定义类型，它不会短路。以未指定的顺序对双方进行评估，然后调用该函数。

不过，我认为其他人已经解决了您需要回答的问题。

Answer 6

如果我没记错的话，该操作是未定义的。分配给 to 变量，然后在单个语句中引用同一变量是未定义的。

Answer 7

我通常总是使用括号只是为了让我的代码更清楚地表达我的意图。

Answer 8

它是从左到右评估的。

然而，在您的情况下，赋值是最后发生的事情，并且整个事情的行为如下（其中 alpha 用作计算的一部分以获取结果来初始化它）：

if (int alpha = (value1-value2 && alpha > 0.001))

您不能将变量声明混合到复杂的表达式中，因此以下内容将无法编译：

if ((int alpha = value1-value2) && (alpha > 0.001))

因此您需要将其分成两行：

int alpha = value1 - value2;
if (alpha > 0.001)

Answer 9

if (int alpha = value1-value2 && alpha > 0.001)

根据规则将按

1.  (value1-value2)   [evaluate subtraction]
2.  && (left side)    [test left side]
3.  (alpha > 0.001)   [evaluated only if value-value2 != 0]
4.  && (right side)   [test right side]
4.  alpha =           [assignment]

步骤3中的顺序进行评估，首先评估 alpha。由于它还没有被分配——也许还没有声明，规则对此并不清楚——它会产生一个错误。

缺陷是赋值的优先级低于 &&。仍然不起作用，但更接近：

if (int alpha = value1-value2, alpha > 0.001)

Gcc 给出错误：'int' 之前的预期表达式。好吧，也许还没有更近。在最初的声明中，gcc 也说了同样的话。

Answer 10

我的猜测是，这是因为您在“if”语句中声明了存储。我什至认为这不会编译。

试试这个。

int alpha;
if ((alpha=value1-value2) && alpha>0.001)

但我不认为这符合您的需要。您将 alpha 作为 int 类型，然后将其与浮点值进行比较。 && 的第一部分只要 alpha 不为零，语句就会返回 true，如果 alpha 大于 0，第二部分将返回 true。因此，您可能应该这样做

int alpha;
if ((alpha=value1-value2)>0)

或获得更具可读性的代码，

int alpha=value1-value2
if (alpha>0)

但要回答您原来的问题： &&从左到右执行并在答案明显时短路。即，如果 && 的第一部分是是假的，第二个甚至没有被评估！

Answer 11

这是一篇文章列出运算符优先级和关联性。

据我所知，您的意图是声明一个临时变量，为其分配 value1-value2 的值，然后测试结果，如果大于某个值则进入 if 块。 alpha 被声明为 int，但您似乎将其与 double 进行比较。 alpha 应该是双精度的。

您在使用临时工具方面很有创意。清晰往往比可爱更好。改为这样做：

double alpha = value1-value2;
if (alpha > 0.001)

Answer 12

根据 ：
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

- LtR
> LtR
&& LtR
= RtL

给出你的例子

(int alpha = value1-value2 && alpha > 0.001)
(int alpha = (value1-value2) && alpha > 0.001)
(int alpha = (value1-value2) && (alpha > 0.001))
(int alpha = (value1-value2) && (alpha > 0.001))
(int alpha = ((value1-value2) && (alpha > 0.001)))

Answer 13

正如所写，此表达式执行以下操作：

1. 计算 value1 - value2 并通过与零进行隐式比较将其转换为 bool - 即，它实际上是 (value1 - value2 ) != 0
2. 计算 alpha >将 0.001 截断为 int(0) 后为 0.001。 此时 alpha 尚未初始化。
3. 计算前两个计算的逻辑与
4. 转换逻辑与<的布尔结果< /em> 返回一个整数

我认为这总结了帖子的其余部分。我发布单独答案的唯一原因是我找不到一个提到当 alpha 未初始化时以及此处发生的所有转换的答案； wallyk 的回答最接近。

当然，建议您使用括号和单独声明 alpha 的其余答案正是您应该解决此问题的方法。在 if 语句中声明变量是语言的一部分，我还没有找到很好的用途 - 在重复结构中声明似乎更合适。

Answer 14

问题在于该语句的计算方式如下：

if (int alpha = (value1-value2 && alpha > 0.001))

使用括号来修复&&运算符：

if ((int alpha = value1-value2) && (alpha > 0.001))