为什么“ & &”而不是“ &”？

好吧，从表面上看

    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，就不用检查钥匙了，可能会花更长的时间。

逻辑运算符(||和 &&)与按位运算符(|和 &)。

逻辑运算符和位运算符之间最重要的区别是，逻辑运算符接受 两个布尔值并产生一个布尔值，而位运算符接受 两个整数并产生一个整数(注意: 整数意味着任何整数数据类型，而不仅仅是 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，如果你刚刚使用了逻辑运算符，结果也会是一样的。

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

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

翻译过来就是: 如果一个人存在(即不是无效的) ，尝试打他/她，如果打他/她成功(即返回真值) ，然后跳一支胜利之舞。

如果使用位运算符，则如下:

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

翻译成: 如果某人存在(即不为零) ，而冲击成功(即为真) ，则跳胜利之舞。

注意，在短路逻辑运算符中，如果 person为空，则 person.punch()代码可能根本不会运行。实际上，在这种特殊情况下，如果 person为 null，那么第二个代码将产生 null 引用错误，因为无论 person 是否为 null，它都会尝试调用 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 文件系统权限。

简而言之:

1 && 2 = 真
因为
1 = C 中的 true (非零)
2 = 在 C 中为真(非零)

逻辑上与 true一起给出 true。

但是

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

用0010按位设置0001 AND，以十进制表示0000 = 0。

对于 | | 和 | 操作员也是如此... ！

因为 &&和 ||用于 流量控制，就像 if/else一样。并不总是条件句。以 一份声明,而不是以 if或 while条件式写作是完全合理的，如下:

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

甚至

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

这不仅仅是因为它们比同等的 if/else版本更容易输入; 它们也更容易阅读和理解。

意思完全不同，给你两个不同的答案。

1 && 2产生1(“ true”)
1 & 2的收益率为0(“ false”)

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

当在逻辑表达式(如 if 语句)中使用时，最好使用 &&，因为一旦遇到第一个假结果，它就会停止计算表达式。这是可能的，因为假值将导致整个表达式为 false。类似地(在逻辑表达式中也是如此) ，||更可取，因为一旦遇到真表达式，它将停止计算表达式，因为任何真值都将导致整个表达式为真。

然而，如果表达式或-ed 或-ed 一起有副作用，并且您希望所有这些作为表达式的结果发生(不管逻辑表达式的结果如何) ，那么可以使用 &和 |。相反，&&和 ||操作符可以用来防止不必要的副作用(例如导致抛出异常的空指针)。

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

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，则不会执行“ something”，因为 1 & 2为零。

C # 要求像 if这样的条件语句有一个布尔 oeprand，并且该语言不允许将整数值转换为布尔值。因此，上面的代码将生成编译器错误。更正确的表述如下:

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

这是向那些不需要了解代码的确切操作的人解释这一点的最快方法(并且稍微简化了一些)

正在检查每个条件 直到，它发现一个 false 并将整个结果返回为 false

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