C语言中逻辑运算符(&&，||，!)和位运算符号(&，|，^)

井木轩

1.  C语言中逻辑运算符(&&，||，!)和位运算符号(&，|，^)的区别
在C语言中，编程者经常混淆两组运算符：（&&，||，！）和（&，|，^）。第一组是逻辑运算符，它的操作数是布尔型，而第二组则是位运算符，其操作数是位序列。在布尔型操作数中，只有两个数值，0或1。C语言规定，在逻辑运算中，所有的非0数值都看做1处理。而位序列则可以是有无符号的字符型，整型，长短整型等。在位运算中，是相应的位之间进行逻辑运算。因此，从逻辑上讲，位运算过程包含多个逻辑运算过程。通常，位运算操作数选择无符号型数据。

1.1.    应用实例
显示代码打印
01 #include   
02 int main(int argc, char *argvs[])   
03 {   
04       unsigned int a = 0x11;   
05 unsigned int b = 0x00;   
06 unsigned short s = 0x10;   
07 unsigned char c = 0x01;   
08   
09 /* Logic operation */  
10 if(a&&b) printf(“True: a && b is %d \n”, a&&b);   
11 else printf(“False: a && b is %d \n”, a&&b);   
12   
13 if(a&&s) printf(“True: a && s is %d \n”, a&&s);   
14 else printf(“False: a && s is %d \n”, a&&s);   
15   
16 if(a&&c) printf(“True: a && c is %d \n”, a&&c);   
17 else printf(“False: a && c is %d \n”, a&&c);   
18   
19 if(s&&c) printf(“True: s && c is %d \n”, s&&c);   
20 else printf(“False: s && c is %d \n”, s&&c);   
21   
22 /* Bit operation */  
23 printf(“a & b is %x \n”, a&b);   
24 printf(“a & s is %x \n”, a&s);   
25 printf(“a & c is %x \n”, a&c);   
26 printf(“s & c is %x \n”, s&c);   
27 printf(“a & 0x110 is %x \n”, a&0x110);   
28   
29 return 0;   
30 }

执行结果是：

显示代码打印
1 False: a && b is 0   
2 True: a && s is 1   
3 True: a && c is 1   
4 True: s && c is 1   
5 a & b is 0   
6 a & s is 10   
7 a & c is 1   
8 s & c is 0   
9 a & 0x110 is 10

1.2.    长度问题  
在上面的使用案例中，读者应该很容易明白执行的结果，但是，有没有考虑到执行结果的长度呢？下面是一个打印不同情况下表达式结果的长度的程序。
显示代码打印
01 #include   
02 int main(int argc, char *argvs[])   
03 {   
04         unsigned int  a = 0;   
05         unsigned short b = 0;   
06         unsigned char c = 0;   
07   
08         printf("int size = %d short size = %d char size = %d\n", sizeof(unsigned int), sizeof(unsigned short), sizeof(unsigned char));   
09   
10         printf("a&b %d\n", sizeof(a & b));   
11         printf("a&c %d\n", sizeof(a & c));   
12         printf("b&c %d\n", sizeof(b & c));   
13         printf("2&c %d\n", sizeof(2 & c));   
14         printf("2&b %d\n", sizeof(2 & b));   
15         printf("2&a %d\n", sizeof(2 & a));   
16         printf("1&c %d\n", sizeof(1 & c));   
17         printf("1&b %d\n", sizeof(1 & b));   
18         printf("1&a %d\n", sizeof(1 & a));   
19         printf("0&c %d\n", sizeof(0 & c));   
20         printf("0&b %d\n", sizeof(0 & b));   
21         printf("0&a %d\n", sizeof(0 & a));   
22   
23         printf("a&&b %d\n", sizeof(a && b));   
24         printf("a&&c %d\n", sizeof(a && c));   
25         printf("b&&c %d\n", sizeof(b && c));   
26         printf("2&&c %d\n", sizeof(2 && c));   
27         printf("2&&b %d\n", sizeof(2 && b));   
28               printf("2&&a %d\n", sizeof(2 && a));   
29         printf("1&&c %d\n", sizeof(1 && c));   
30         printf("1&&b %d\n", sizeof(1 && b));   
31         printf("1&&a %d\n", sizeof(1 && a));   
32         printf("0&&c %d\n", sizeof(0 && c));   
33         printf("0&&b %d\n", sizeof(0 && b));   
34         printf("0&&a %d\n", sizeof(0 && a));   
35        return 0;   
36 }

在LINUX下面用GCC得到的结果是：

显示代码打印
01 int size = 4 short size = 2 char size = 1   
02 a&b 4   
03 a&c 4   
04 b&c 4   
05 2&c 4   
06 2&b 4   
07 2&a 4   
08 1&c 4   
09 1&b 4   
10 1&a 4   
11 0&c 4   
12 0&b 4   
13 0&a 4   
14 a&&b 4   
15 a&&c 4   
16 b&&c 4   
17 2&&c 4   
18 2&&b 4   
19 2&&a 4   
20 1&&c 4   
21 1&&b 4   
22 1&&a 4   
23 0&&c 4   
24 0&&b 4   
25 0&&a 4   
26 而在WINDOWS下面用VC得到的结果确是：   
27 int size = 4 short size = 2 char size = 1   
28 a&b 4   
29 a&c 4   
30 b&c 4   
31 2&c 4   
32 2&b 4   
33 2&a 4   
34 1&c 4   
35 1&b 4   
36 1&a 4   
37 0&c 4   
38 0&b 4   
39 0&a 4   
40 a&&b 1   
41 a&&c 1   
42 b&&c 1   
43 2&&c 1   
44 2&&b 1   
45 2&&a 1   
46 1&&c 1   
47 1&&b 1   
48 1&&a 1   
49 0&&c 4   
50 0&&b 4   
51 0&&a 4

从两种结果中我们很清晰的得出一个结论，逻辑运算结果的长度是由编译器决定的。因此在使用到逻辑运算结果的时候，要首先判断其长度。

1.3.    使用问题
这里的使用问题就是操作符使用的混淆，下面有一个简单的例子。

显示代码打印
1 if((a > b) && (c > d)) {   
2     printf(“true\n”);   
3 } else {   
4     printf(“false\n”);   
5 }

在这种情况下，如果将&&误写为&，结果会如何呢。如果仔细分析会发现，执行结果依然正确。但是，这种情况很特殊，1）是&&被换成了&，而不是||被换成|；2）a>b和c>d的值要么是1，要么是0；3）当1和0进行&&或&操作时，结果相同(1或0)。因此，在这种情况下，是一种“侥幸”！

rxfeng

涨知识！