为什么'&&'而不是'&'？

Question

为什么 && 优于 & 且 || 优于 |？

我问了一个多年来一直在编程的人，他的解释是：

例如，在 if (bool1 && bool2 && bool3) { /*DoSomething*/ } 中，bool1 必须为 true 才能测试 bool2，在转向 bool3 之前必须为 true。如果我使用了单个& 相反，即使所有测试都必须正确才能进入下一行，但测试没有顺序，那么为什么它很重要呢？

注意：我想指出的是，我的编程能力相当于一个幼儿，这不是一个严肃或紧急的问题。更重要的是理解为什么事情应该以某种方式而不是另一种方式完成。

Answer 1

在大多数情况下，&& 和 || 优于 & 和 |，因为前者短路，即结果明确后立即取消评估。

示例：

if(CanExecute() && CanSave())
{
}

如果 CanExecute 返回 false，则完整表达式将为 false，无论 CanSave 的返回值如何。因此，CanSave 不会被执行。

这在以下情况下非常方便：

string value;
if(dict.TryGetValue(key, out value) && value.Contains("test"))
{
    // Do Something
}

如果在字典中找不到提供的键，则 TryGetValue 返回 false。由于 && 的短路性质，value.Contains("test") 仅在 TryGetValue 返回 < code>true 因此 value 不是 null。如果您使用按位与运算符&，如果在字典中找不到该键，您将得到一个NullReferenceException，因为在任何情况下都会执行表达式的第二部分。

一个类似但更简单的示例是以下代码（如 TJHeuvel 提到的）：

if(op != null && op.CanExecute())
{
    // Do Something
}

仅当 op 不为 null 时才执行 CanExecute。如果 op 为 null，则表达式的第一部分 (op != null) 计算结果为 false，并且其余部分的评估 (op.CanExecute()) 将被跳过。

除此之外，从技术上来说，它们也不同：
&& 和 || 只能用于 bool，而 & 和 |< /code> 可用于任何整数类型（bool、int、long、sbyte、... )，因为它们是按位运算符。 & 是按位 AND 运算符，| 是按位 OR 运算符。

更准确地说，在 C# 中，这些运算符（&、| [和 ^]）称为“逻辑运算符”（请参阅C# 规范，第 7.11 章）。这些运算符有多种实现：

1. 对于整数（int、uint、long 和 ulong，第 7.11 章。 1):
   它们被实现来计算操作数和运算符的按位结果，即 & 被实现来计算按位逻辑 AND 等。
2. 对于枚举（第 7.11.2 章） :
   它们被实现来执行枚举的基础类型的逻辑操作。
3. 对于布尔值和可为 null 的布尔值（第 7.11.3 和 7.11.4 章）：
   结果不是使用按位计算来计算的。结果基本上是根据两个操作数的值来查找的，因为可能性的数量太少了。
   由于两个值都用于查找，因此此实现不会短路。

Answer 2

非常清楚地解释这意味着什么（即使其他答案暗示它 - 但可能使用您不理解的术语）。

以下代码：

if (a && b)
{
   Foo();
}

真正编译为：

if (a)
{
    if (b)
    {
        Foo();
    }
}

其中以下代码完全按照其表示的方式编译：

if (a & b)
{
   Foo();
}

这称为短路。一般来说，您应该始终在您的条件中使用 && 和 || 。

奖励分数：有一种情况是您不应该这样做的。如果您处于性能至关重要的情况（这是纳秒至关重要），则仅在必须时才使用短路（例如null检查） - 作为短路-电路是分支/跳转；这可能会导致 CPU 上的分支预测错误； & 比 && 便宜得多。还有一种情况，短路实际上会破坏逻辑 - 看看 我的这个答案。

谩骂/独白：关于最幸福地忽略的分支错误预测。引用 Andy Firth（一直致力于游戏开发） 13 年）：“这可能是人们认为他们需要达到的较低水平......但他们错了。了解您正在编程的硬件如何处理分支可以极大地影响性能程度……远远超过大多数程序员可能欣赏的《re：千刀万剐》。”

• 游戏开发者（以及其他在极端实时条件下工作的人）甚至会重构他们的逻辑以更好地适应预测器。反编译的 mscorlib 代码中也有这方面的证据。
• 仅仅因为 .NET 使您免受此类事情的影响，并不意味着它不重要。在 60 Hz 下，分支错误预测的代价极其高昂；或每秒 10,000 个请求。
• 英特尔不会有工具来识别错误预测的位置，Windows 也不会为此提供性能计数器，也不会有一个词来描述它，如果这不是一个问题的话。
• 对较低层次和架构的无知并不意味着了解它们的人就错了。
• 始终尝试了解您正在使用的硬件的局限性。

这是非信徒的基准。最好以 RealTime/High 运行该进程，以减轻调度程序的影响：https://gist.github。 com/1200737

Answer 3

逻辑运算符（|| 和 &&）与按位运算符（| 和 &）。

逻辑运算符和按位运算符之间最重要的区别在于，逻辑运算符采用两个布尔值并生成一个布尔值，而按位运算符采用两个整数并生成一个整数（注意：整数表示任何整数数据类型，而不仅仅是 int）。

迂腐地说，按位运算符采用位模式（例如 01101011）并对每个位执行按位 AND/OR 操作。因此，例如，如果您有两个 8 位整数：

a     = 00110010 (in decimal:    32+16+2   = 50)
b     = 01010011 (in decimal: 64+   16+2+1 = 83)
----------------
a & b = 00010010 (in decimal:       16+2   = 18)
a | b = 01110011 (in decimal: 64+32+16+2+1 = 115)

而逻辑运算符仅适用于 bool：

a      = true
b      = false
--------------
a && b = false
a || b = true

其次，通常可以在 bool 上使用按位运算符，因为 true 和 false 相当于 1和 0 分别，并且恰好将 true 翻译为 1，将 false 翻译为 0，然后进行按位运算，然后将非零转换为 true，将 0 转换为 false；如果您刚刚使用逻辑运算符，结果会是相同的（检查此练习）。

另一个重要的区别是逻辑运算符是短路的。因此，在某些圈子[1]中，你经常会看到人们做这样的事情：

if (person && person.punch()) {
    person.doVictoryDance()
}

“如果人存在（即不为空），则尝试打他/她，如果打成功（即返回 true），然后跳一支胜利之舞”。

如果您使用按位运算符，则：

if (person & person.punch()) {
    person.doVictoryDance()
}

将转换为：“如果人存在（即不为空）并且出拳成功（即返回 true），则跳胜利之舞”。

请注意，在短路逻辑运算符中，如果 person 为 null，则 person.punch() 代码可能根本不会运行。事实上，在这种特殊情况下，如果 person 为 null，第二个代码将产生空引用错误，因为无论 person 是否为空，它都会尝试调用 person.punch()是否为空。这种不评估正确操作数的行为称为短路。

[1] 一些程序员会反对将具有副作用的函数调用放入 if 表达式中，而对于其他程序员来说，这是一种常见且非常有用的习惯用法。

由于按位运算符一次在 32 位上运行（如果您使用的是 32 位机器），因此如果您需要比较大量条件（例如，

int CAN_PUNCH = 1 << 0, CAN_KICK = 1 << 1, CAN_DRINK = 1 << 2, CAN_SIT = 1 << 3,
    CAN_SHOOT_GUNS = 1 << 4, CAN_TALK = 1 << 5, CAN_SHOOT_CANNONS = 1 << 6;

Person person;
person.abilities = CAN_PUNCH | CAN_KICK | CAN_DRINK | CAN_SIT | CAN_SHOOT_GUNS;

Place bar;
bar.rules = CAN_DRINK | CAN_SIT | CAN_TALK;

Place military;
military.rules = CAN_SHOOT_CANNONS | CAN_PUNCH | CAN_KICK | CAN_SHOOT_GUNS | CAN_SIT;

CurrentLocation cloc1, cloc2;
cloc1.usable_abilities = person_abilities & bar_rules;
cloc2.usable_abilities = person_abilities & military_rules;

// cloc1.usable_abilities will contain the bit pattern that matches `CAN_DRINK | CAN_SIT`
// while cloc2.usable_abilities will contain the bit pattern that matches `CAN_PUNCH | CAN_KICK | CAN_SHOOT_GUNS | CAN_SIT`

执行相同操作 ），它可以生成更优雅、更快的代码使用逻辑运算符将需要大量的比较：

Person person;
person.can_punch = person.can_kick = person.can_drink = person.can_sit = person.can_shoot_guns = true;
person.can_shoot_cannons = false;

Place bar;
bar.rules.can_drink = bar.rules.can_sit = bar.rules.can_talk = true;
bar.rules.can_punch = bar.rules.can_kick = bar.rules.can_shoot_guns = bar.rules.can_shoot_cannons = false;

Place military;
military.rules.can_punch = military.rules.can_kick = military.rules.can_shoot_guns = military.rules.can_shoot_cannons = military.rules.can_sit = true;
military.rules.can_drink = military.rules.can_talk = false;

CurrentLocation cloc1;
bool cloc1.usable_abilities.can_punch         = bar.rules.can_punch         && person.can_punch,
     cloc1.usable_abilities.can_kick          = bar.rules.can_kick          && person.can_kick,
     cloc1.usable_abilities.can_drink         = bar.rules.can_drink         && person.can_drink,
     cloc1.usable_abilities.can_sit           = bar.rules.can_sit           && person.can_sit,
     cloc1.usable_abilities.can_shoot_guns    = bar.rules.can_shoot_guns    && person.can_shoot_guns,
     cloc1.usable_abilities.can_shoot_cannons = bar.rules.can_shoot_cannons && person.can_shoot_cannons
     cloc1.usable_abilities.can_talk          = bar.rules.can_talk          && person.can_talk;

bool cloc2.usable_abilities.can_punch         = military.rules.can_punch         && person.can_punch,
     cloc2.usable_abilities.can_kick          = military.rules.can_kick          && person.can_kick,
     cloc2.usable_abilities.can_drink         = military.rules.can_drink         && person.can_drink,
     cloc2.usable_abilities.can_sit           = military.rules.can_sit           && person.can_sit,
     cloc2.usable_abilities.can_shoot_guns    = military.rules.can_shoot_guns    && person.can_shoot_guns,
     cloc2.usable_abilities.can_talk          = military.rules.can_talk          && person.can_talk,
     cloc2.usable_abilities.can_shoot_cannons = military.rules.can_shoot_cannons && person.can_shoot_cannons;

使用位模式和按位运算符的典型示例是在 Unix/Linux 文件系统权限中。

Answer 4

在以下情况下：

if (obj != null && obj.Property == true) { }

将按预期工作。

但是：

if (obj != null & obj.Property == true) { }

可能会引发空引用异常。

Answer 5

简短而简单：

1 && 2 = true
因为
1 = C 中的 true（非零）
C 中的 2 = true（非零）

true 与 true 进行逻辑与得到 true。

但是

1 & 2 = 0 = 假
因为
1 = 二进制 0001
2 = 二进制 0010

0001 与 0010 按位与，得到十进制 0000 = 0。

对于 || 同样如此和 |运营商也...！

Answer 6

&& 是 & 的短路版本。

如果我们正在评估 false & true，从第一个参数我们已经知道结果将为 false。 && 版本的运算符将尽快返回结果，而不是计算整个表达式。还有一个类似版本的 | 运算符 ||。

Answer 7

if (list.Count() > 14 && list[14] == "foo")

安全会崩溃。

if (list.Count() > 14 & list[14] == "foo")

如果列表的大小不正确，则

Answer 8

C# 运算符 应该解释原因：

本质上有两个 & 或 | 意味着它是条件而不是逻辑，因此您可以区分 二。

& Operator 有一个使用 & 的示例。

Answer 9

好的，从表面上看，

    Boolean a = true;
    Boolean b = false;

    Console.WriteLine("a({0}) && b({1}) =  {2}", a, b, a && b);
    Console.WriteLine("a({0}) || b({1}) =  {2}", a, b, a || b);
    Console.WriteLine("a({0}) == b({1}) =  {2}", a, b, a == b);

    Console.WriteLine("a({0}) & b({1}) =  {2}", a, b, a & b);
    Console.WriteLine("a({0}) | b({1}) =  {2}", a, b, a | b);
    Console.WriteLine("a({0}) = b({1}) =  {2}", a, b, a = b);

会产生相同的答案。但是，正如您所展示的，如果您有一个更复杂的问题，那么：

if (a and b and c and d) ..

如果 a 不正确，并且可能 b 是一个必须关闭的函数，请连接到某个东西，得到这个，做那个，做出决定..何苦呢？浪费时间，你知道它已经失败了。为什么要让机器停机并做额外的无意义的工作？

我一直使用 && 因为我把最有可能失败的放在第一位，因此，在没有意义的情况下，在继续之前进行更少的计算。如果无法预测不太可能的选择，例如您有一个布尔值来限制数据输出，例如：

if (limit && !MyDictionary.ContainsKey("name")) 
    continue;

如果不是 limit，则不必费心检查密钥，这可能需要更长..

Answer 10

当在逻辑表达式（例如 if 语句）中使用时，&& 更好，因为一旦遇到第一个错误结果，它就会停止计算表达式。这是可能的，因为假值将导致整个表达式为假。类似地（同样在逻辑表达式中） || 更可取，因为一旦遇到 true 表达式，它就会停止计算表达式，因为任何 true 值都会导致整个表达式为 true。

但是，如果 or 或 and 一起的表达式有副作用，并且您希望所有这些都作为表达式的结果发生（无论逻辑表达式的结果如何），则 &和|。相反，&& 和 || 运算符可用于防止不必要的副作用（例如导致引发异常的空指针）。

& 和 | 运算符也可以与整数一起使用，在这种情况下，它们生成一个整数结果，该结果是两个操作数在位级别。当整数值的二进制位用作真值和假值的数组时，这非常有用。为了测试某个位是打开还是关闭，位掩码与该值进行按位与运算。要打开某个位，可以将同一掩码与该值进行按位或运算。最后要关闭一点，掩码的按位补码（使用 ~）与值进行按位与运算。

int a = 0; // 0 means all bits off
a = a | 4; // set a to binary 100
if ((a & 4) != 0) {
    // will do something
}
a = a & (~4) // turn bit off again, a is now 000

在 C# 以外的语言中，必须注意 & 的逻辑模式与按位模式。和|。在上面的代码中，if 语句的条件表达式 (a & 4) != 0 是表达此条件的安全方式，但在许多类似 C 的语言中，条件表达式语句可以简单地将零整数值视为 false，将非零整数值视为 true。 （其原因与可用的条件分支处理器指令以及它们与每次整数运算后更新的零标志的关系有关。）因此可以删除 ìf 语句对零的测试，并且条件可以缩短为(a & 4)。

当使用按位和运算符组合表达式返回没有位对齐的值时，这可能会导致混乱，甚至可能出现问题。考虑以下示例，其中需要两个函数的副作用，然后再检查它们是否都成功（按照它们返回非零值的定义）：

if (foo() & bar()) {
    // do something
}

在 C 中，如果 foo() 返回1 且 bar() 返回 2，“某事”不会完成，因为 1 & 2 为零。

C# 要求像 if 这样的条件语句具有布尔值，并且该语言不允许将整数值转换为布尔值。所以上面的代码会产生编译器错误。更正确的表达方式如下：

if (foo() != 0 & bar() != 0) {
    // do something
}

Answer 11

如果您是一位老 C 程序员，请小心。 C# 真的让我很惊讶。

MSDN 表示 | 运算符：

二进制 |运算符是为整数类型和bool预定义的。对于整数类型，|计算其操作数的按位或。对于布尔操作数，|计算其操作数的逻辑或；也就是说，当且仅当两个操作数都为 false 时，结果才为 false。

（强调是我的。）布尔类型是经过特殊处理的，在这种情况下，问题才开始有意义，区别在于，正如其他人在其答案中已经解释的那样：

&& 和 || 是短路的。 & 和 | 计算两个操作数。

更可取的取决于许多因素，例如副作用、性能和代码可读性，但通常短路运算符更可取，因为像我这样具有相似背景的人可以更好地理解它们。

原因是：我会这样论证：由于 C 中没有真正的布尔类型，因此您可以使用按位运算符 | 并在 if 条件下将其结果评估为 true 或 false。但这对于 C# 来说是错误的态度，因为布尔类型已经有了特殊情况。

Answer 12

这很重要，因为如果 bool2（例如）的评估成本很高，但 bool1 为假，那么您可以通过使用 && 节省大量计算量。超过&

Answer 13

因为&&和||就像if/else一样用于流控制。它并不总是与条件有关。写成语句是完全合理的，而不是写成if或while条件，如下：

 a() && b() && c() && d();

或者甚至

 w() || x() || y() || z();

不仅仅是它这些比等效的 if/else 版本更容易输入；它们也更容易阅读和理解。

Answer 14

&&和&意味着两个截然不同的事情并给你两个不同的答案。

<代码>1 && 2 产生 1（“true”）
<代码>1 & 2 产生 0（“假”）

&& 是一个逻辑运算符 - 它的意思是“如果两个操作数都为 true，则为 true”
& 是按位比较。它的意思是“告诉我两个操作数中设置了哪些位”

Answer 15

向不需要知道代码的确切操作的人解释这一点的最快（并且稍微简单）的方法是

&& 是对每个条件进行检查< strong>Until 它找到一个 false 并将整个结果返回为 false

|| 正在对每个条件进行检查 Until 它找到一个 true 并返回整个结果都是真实的。

& 正在根据两个/所有条件进行数学计算并处理结果。

| 正在根据两个/所有条件进行数学计算并处理结果。

我从未遇到过需要在 if 语句中使用 & 或 | 的情况。我主要使用它通过按位移位将十六进制值分割为其分量颜色。

EG：

r = fullvalue >> 0xFF & 0xFF;
g = fullvalue >> 0xF & 0xFF;
b = fullvalue & 0xFF;

在此操作中“& 0xFF”强制仅查看二进制值。
不过，我个人还没有发现 | 的用途。

Answer 16

简单来说，

if exp1 && exp2

如果 exp1 是 flase
不检查 exp2，

而是检查

if exp1 & exp2

如果 exp1 为 false 或 true
检查 exp2

并且很少有人使用 & 因为他们很少想在 exp1 为 false 时检查 exp2