C语言中逻辑运算符(&&,||,!)和位运算符号(&,|,^)的区别 
 
 
1.     C语言中逻辑运算符(&&,||,!)和位运算符号(&,|,^)的区别  
 
在C语言中,编程者经常混淆两组运算符:(&&,||,!)和(&,|,^)。 
 
第一组是逻辑运算符,它的操作数是布尔型,而第二组则是位运算符,其操作数是位序列。 
 
在布尔型操作数中,只有两个数值,0或1。C语言规定,在逻辑运算中,所有的非0数值都看做1处理。 
 
而位序列则可以是有无符号的字符型,整型,长短整型等。在位运算中,是相应的位之间进行逻辑运算。 
 
因此,从逻辑上讲,位运算过程包含多个逻辑运算过程。通常,位运算操作数选择无符号型数据。 
 
 
 
1.1.    应用实例 
 
代码: 
 
#include   
int main(int argc, char *argvs[])  
{  
      unsigned int a = 0x11;  
unsigned int b = 0x00;  
unsigned short s = 0x10;  
unsigned char c = 0x01;  
 
/* Logic operation */  
if(a&&b) printf(“True: a && b is %d \n”, a&&b);  
else printf(“False: a && b is %d \n”, a&&b);  
 
if(a&&s) printf(“True: a && s is %d \n”, a&&s);  
else printf(“False: a && s is %d \n”, a&&s);  
 
if(a&&c) printf(“True: a && c is %d \n”, a&&c);  
else printf(“False: a && c is %d \n”, a&&c);  
 
if(s&&c) printf(“True: s && c is %d \n”, s&&c);  
else printf(“False: s && c is %d \n”, s&&c);  
 
/* Bit operation */  
printf(“a & b is %x \n”, a&b);  
printf(“a & s is %x \n”, a&s);  
printf(“a & c is %x \n”, a&c);  
printf(“s & c is %x \n”, s&c);  
printf(“a & 0x110 is %x \n”, a&0x110);  
 
return 0;  
}  
 
  
(原文件名:未命名.JPG)  
 
 
执行结果是:  
 
False: a && b is 0   
True: a && s is 1   
True: a && c is 1   
True: s && c is 1   
a & b is 0   
a & s is 10   
a & c is 1   
s & c is 0   
a & 0x110 is 10  
 
  
(原文件名:未命名.JPG)  
 
 
 
1.2.    长度问题   
在上面的使用案例中,读者应该很容易明白执行的结果,但是,有没有考虑到执行结果的长度呢?下面是一个打印不同情况下表达式结果的长度的程序。 
 
#include   
int main(int argc, char *argvs[])  
{  
        unsigned int  a = 0;  
        unsigned short b = 0;  
        unsigned char c = 0;  
 
        printf("int size = %d short size = %d char size = %d\n", sizeof(unsigned int), sizeof(unsigned short), sizeof(unsigned char));  
 
        printf("a&b %d\n", sizeof(a & b));  
        printf("a&c %d\n", sizeof(a & c));  
        printf("b&c %d\n", sizeof(b & c));  
        printf("2&c %d\n", sizeof(2 & c));  
        printf("2&b %d\n", sizeof(2 & b));  
        printf("2&a %d\n", sizeof(2 & a));  
        printf("1&c %d\n", sizeof(1 & c));  
        printf("1&b %d\n", sizeof(1 & b));  
        printf("1&a %d\n", sizeof(1 & a));  
        printf("0&c %d\n", sizeof(0 & c));  
        printf("0&b %d\n", sizeof(0 & b));  
        printf("0&a %d\n", sizeof(0 & a));  
 
        printf("a&&b %d\n", sizeof(a && b));  
        printf("a&&c %d\n", sizeof(a && c));  
        printf("b&&c %d\n", sizeof(b && c));  
        printf("2&&c %d\n", sizeof(2 && c));  
        printf("2&&b %d\n", sizeof(2 && b));  
              printf("2&&a %d\n", sizeof(2 && a));  
        printf("1&&c %d\n", sizeof(1 && c));  
        printf("1&&b %d\n", sizeof(1 && b));  
        printf("1&&a %d\n", sizeof(1 && a));  
        printf("0&&c %d\n", sizeof(0 && c));  
        printf("0&&b %d\n", sizeof(0 && b));  
        printf("0&&a %d\n", sizeof(0 && a));  
       return 0;  
}  
 
  
(原文件名:未命名.JPG)  
 
 
在LINUX下面用GCC得到的结果是:  
 
int size = 4 short size = 2 char size = 1  
a&b 4  
a&c 4  
b&c 4  
2&c 4  
2&b 4  
2&a 4  
1&c 4  
1&b 4  
1&a 4  
0&c 4  
0&b 4  
0&a 4  
a&&b 4  
a&&c 4  
b&&c 4  
2&&c 4  
2&&b 4  
2&&a 4  
1&&c 4  
1&&b 4  
1&&a 4  
0&&c 4  
0&&b 4  
0&&a 4 
 
 
而在WINDOWS下面用VC得到的结果确是: 
 
int size = 4 short size = 2 char size = 1  
a&b 4  
a&c 4  
b&c 4  
2&c 4  
2&b 4  
2&a 4  
1&c 4  
1&b 4  
1&a 4  
0&c 4  
0&b 4  
0&a 4  
a&&b 1  
a&&c 1  
b&&c 1  
2&&c 1  
2&&b 1  
2&&a 1  
1&&c 1  
1&&b 1  
1&&a 1  
0&&c 4  
0&&b 4  
0&&a 4  
 
 
  
(原文件名:未命名.JPG)  
 
从两种结果中我们很清晰的得出一个结论,逻辑运算结果的长度是由编译器决定的。 
 
因此在使用到逻辑运算结果的时候,要首先判断其长度。  
 
1.3.    使用问题  
 
这里的使用问题就是操作符使用的混淆,下面有一个简单的例子。  
 
 
if((a > b) && (c > d)) {  
    printf(“true\n”);  
} else {  
    printf(“false\n”);  
}  
 
  
(原文件名:未命名.JPG)  
 
 
从两种结果中我们很清晰的得出一个结论,逻辑运算结果的长度是由编译器决定的。 
 
因此在使用到逻辑运算结果的时候,要首先判断其长度。 
 
在这种情况下,如果将&&误写为&,结果会如何呢。 
 
如果仔细分析会发现,执行结果依然正确。 
 
但是,这种情况很特殊,1)是&&被换成了&,而不是||被换成|;2)a>b和c>d的值要么是1,要么是0;3) 
 
当1和0进行&&或&操作时,结果相同(1或0)。因此,在这种情况下,是一种“侥幸”! 
 
文章出处:飞诺网(www.diybl.com):http://www.diybl.com/course/3_pr ... 0090507/166733.html |  
  
 
 
 
 
 |   
 |  
  
 |