个人总结操作符的特性，包括：按位操作符、位移操作符和单目操作符中的sizeof

﹏ヽ暗。殇╰゛Y 2022-06-07 07:07 121阅读 0赞

## 按位操作符 ##

**1. 按位与 |**

个人理解，与数学中的交集 ∩ 相似

**特性1.**遇1不变，遇0为0  
两个bit位a,b  
a=1,b=1 a&b=1;  
a=1,b=0 a&b=0;  
a=0,b=0 a&b=0;  
举例说明：  
10的二进制为：00001010；  
5的二进制为：00000101；  
10&5：  
00001010  
00000101  
—————  
00000000  
10&5=0；  
**特性2.**交换律  
例如：（2&3）&4=2&（3&4）  
验证：  
2：0010；  
3：0011；  
4：0100；  
2&3=0010；（2&3）&4=0000；  
3&4=0000；2&（3&4）=0000；

**没有结合律**  
例如：5&3+5&2和5&（3+2）是不相等的，前者等于5，后者等于0，可自行验证；

**特性3.**  
a&a=a;  
a&0=0;  
a&（-1）=a;（因为-1的补码是全1，则结果不变（特性1））  
奇数&1=1；偶数&1=0；  
（因为奇数的第一位二进制位是1，偶数的第一位二进制位是0）

**特性4.**一个数持续与它本身减一做按位与运算，最终会得到0；  
例如：

int main()
    {
    int n=23;
    while(n)
    {
         n=n&(n-1);
    }//最终，循环会跳出，即n=0；
    return 0;
    }

并且，循环次数与二进制中1的个数相同。

例如：

int main()
    {
    int n=10;//二进制为：0000 1010
    int count=0;
    while(n)
    {
         n=n&(n-1);
         count++;
    }//最终，循环会跳出，count=2；
    return 0;
    }

**2. 按位或 |**

个人理解，与数学中的并集∪相似

**特性1.**遇0不变，遇1为1  
两个bit位a,b  
a=1,b=1 a|b=1;  
a=1,b=0 a|b=1;  
a=0,b=0 a|b=0;  
举例说明：  
10的二进制为：00001010；  
5的二进制为：00000101；  
10|5：  
00001010  
00000101  
—————  
00001111  
10|5=31；  
**特性2.**交换律  
例如：（2|3）|4=2|（3|4）  
验证：  
2：0010；  
3：0011；  
4：0100；  
2|3=0011；（2|3）|4=0111；  
3|4=0111；2|（3|4）=0111；

**没有结合律**  
例如：5|3+5|2和5|（3+2）是不相等的，前者等于15，后者等于5，可自行验证；

**特性3.**  
a|a=a;  
a|0=a;  
a|（-1）=-1;（因为-1的补码是全1，则结果变1（特性1））  
奇数&1=奇数；偶数&1=偶数+1；  
（因为奇数的第一位二进制位是1，偶数的第一位二进制位是0）

**3. 按位异或 ^**

**特性1.**同0异1（相同为0，不同为1）  
两个bit位a,b  
a=1,b=1 a^b=0;  
a=1,b=0 a^b=1;  
a=0,b=0 a^b=0;  
举例说明：  
10的二进制为：00001010；  
5的二进制为：00000101；  
10^5：  
00001010  
00000101  
—————  
00001111  
10^5=15；  
**特性2.**交换律  
例如：（2^3）^4=2^（3^4）  
验证：  
2：0010；  
3：0011；  
4：0100；  
2^3=0001；（2^3）^4=0101；  
3^4=0111；2^（3^4）=0101；

**没有结合律**  
例如：5^3+5^2和5^（3+2）是不相等的，前者等于15，后者等于0，可自行验证；

**特性3.**  
a^a=0;  
a^0=a;

## 位移操作符 ##

**1. 左移**

左移操作符：<<  
将二进制位向左移位，左边丢弃，右边补0  
例如：  
25的二进制是：  
00000000 00000000 00000000 00011001  
25<<1：  
00000000 00000000 00000000 00110010  
25<<8：  
00000000 00000000 00011001 00000000

**2. 右移**  
右移操作符：>>  
（根据编译器不同，分成算术右移和逻辑右移，一般都是算术右移）  
（1）算术右移  
将二进制位向右移位，右边丢弃，左边补符号位  
例如：  
\-25的二进制是：  
10000000 00000000 00000000 00011001  
\-25<<1：  
11000000 00000000 00000000 00001100  
\-25>>8  
11111111 10000000 00000000 00000000

（2）逻辑右移  
将二进制位向右移位，右边丢弃，左边补0  
例如：  
\-25的二进制是：  
10000000 00000000 00000000 00011001  
\-25<<1：  
01000000 00000000 00000000 00001100  
\-25>>8  
00000000 10000000 00000000 00000000

移位操作符的运算：  
例如：

int n=25;
    n=n>>1;//或者写成n>>=1;
    不能写成
    int n=25;
    n>>1;

否则编译警告：warning C4552: “>>”: 运算符不起任何作用；应输入带副作用的运算符  
“>>和<<”只是个运算符，和+、-等运算符一样，只执行运算的功能，却不会改变操作数的值，因此作为左操作数的a在执行移位操作后会保持原来的值不变  
（3）无符号整数除2的n(n>0)次幂相当于右移n位  
用于有除法运算的时候替换除法，除法是最慢的运算；  
例如：  
4/2替换成4>>1  
64/8替换成64>>3

## 单目操作符：sizeof ##

单目操作符里有一个操作符比较重要：sizeof  
以下几点需注意：  
\*\*1.\*\*sizeof:返回操作数的类型长度，以字节为单位；

在此回顾一个知识点，各数据类型的大小：  
char :1字节； short :2字节； int :4字节；  
long :4或8字节； long long ：8字节； float :4字节；  
double ：8字节

简单几个例子：  
sizeof(int)=4； int a sizeof(a)=4；  
sizeof(char)=1； char a sizeof(a)=1；  
sizeof(double)=8； double a sizeof(a)=8；  
从以上几个例子可以看出sizeof返回的是操作数的类型长度

再补充一些内容：sizeof对地址的操作  
例1：

int main()
    {
                int* p;
                int num=sizeof(p);
                return num;
    }

结果返回为4；  
因为指针存放的是地址，在32位系统下，地址为32位二进制数，即32个bit位，  
1个字节为8个bit，所以地址的大小为4字节；  
例2：

int main()
    {
                int arr[5]={
       1,2,3,4,5};
                int num=sizeof(arr);
                return num;
    }

结果返回为20；  
因为arr在sizeof(arr)中代表整个数组的地址，定义该数组时在内存中分配了  
5个int类型元素的空间，即5个4字节大小的空间。  
例3：

int main()
    {
                int arr[5]={
       1,2,3,4,5};
                int num=sizeof(arr[0]);
                return num;
    }

结果返回为4；  
因为arr\[0\]代表数组中的第一个元素，即1，所以sizeof(arr\[0\])==sizeof(1)==sizeof(int)==4;

\*\*2.\*\*sizeof执行操作时发生在编译阶段，所以不会访问内存  
由此引申两个例题：  
（1）以下代码是否有错？如果没错，返回值是多少

int main()
    {
                int arr[5]={
       1,2,3,4,5};
                int num=sizeof(arr[5]);
                return num;
    }

答案：返回值为4；  
解析：很多人刚开始接触sizeof的时候，会认为arr\[5\]不存在，认为这段代码是错误的。实际上，sizeof是操作符，并非函数；sizeof执行操作时发生在编译阶段，而非运行阶段。虽然arr\[5\]并不存在，但这里也并没有真正地访问arr\[5\]，而是仅仅根据数组元素的类型来确定其值。  
（2）求下面代码的打印结果：

int main()
    {
            int a=10;
            int b=20;
            printf("%d\n",sizeof(a=b+1));
            printf("%d\n",a);
            return 0;
    }

答案：4和10  
解析：“细心”的同学可能会回答4和21，因为a=b+1这部分代码。  
实际上，sizeof执行操作时发生在编译阶段，而非运行阶段；  
所以并没有真正进行运算。

\*\*3.\*\*sizeof不是函数  
很多同学看见sizeof后面跟着（）,就误认为它是函数，实际上不是。  
可用以下方法自行证明：

int main()
    {
            int a=10;
            printf("%d\n",sizeof(a));//打印4
            printf("%d\n",sizeof a);//打印4
            printf("%d\n",sizeof (int));//打印4
            printf("%d\n",sizeof int);//错误
            return 0;
    }

上面的结果可以告诉我们，sizeof并非函数。