1.算术操作符

对于除法操作符，两边的操作数都是整数，执行的是整数除，若想得到小数，除号两端至少有一个为浮点数/取模（取余），计算的是整除之后的余数
取模操作符（%），计算的是整除之后的余数，只能用整型类型的操作

2.原码，反码，补码

a = 10
00000000000000000000000000001010-原码
00000000000000000000000000001010-反码
00000000000000000000000000001010-补码
正数的原码反码补码相同
如b= -10 ，下面写出b的原码，反码，补码
10000000000000000000000000001010-原码–按照一个数的正负，直接写出它的二进制表示形式
11111111111111111111111111110101-反码–原码的符号位不变，其它位取反(第一位是符号位）
11111111111111111111111111110110-补码–反码加1
补码变原码：先符号位不变，其它位按位取反，再+1

3.移位操作符（移（2进制）位操作符）

左移操作符：左边丢掉，右边补0
计算机在存储中存储的永远都是补码，所以在移位时，移动的是补码。
符号位（0是正数，1是负数）
整型占4个字节（32bit）
内存中存储的其实是：补码的二进制
所以在参与移位时，移动的都是补码–所以移位操作符的用法可以了解了
a << 1;//2进制移位
先写出10的补码:
00000000000000000000000000001010
00000000000000000000000000010100 (左移一位后的结果）
但是这个过程a不变，变的是a向左移动的表达式这个结果变，a本身不变
比如： a=10;b=a+2;b=12，但是a本身不变，还是10
若想让a变化，可以写成 a>>=1;（a = a>>1）
printf(“%d\n”, c);//20
int a = -10;
int b = a << 1;
10000000000000000000000000001010–原码
11111111111111111111111111110101–反码
11111111111111111111111111110110–补码
左移操作符：（补码）左边丢掉，右边补0
11111111111111111111111111101100–补码左移后的结果,b的补码
10000000000000000000000000010011–计算过程
10000000000000000000000000010100–b的原码
由于打印（肉眼可见的）出来的都是原码，但是计算机存储的是补码，所以计算机要转换成原码再打印出来
总结，左移1位有×2的效果

右移操作符（看完左移操作符，就懂右移操作符了）
1.算术右移（平常见到）–也是计算机计算的方法
算数右移-右边丢弃，左边补原来的符号位
如 a =-1
100000000000000000000000000000001–a的原码
111111111111111111111111111111110–a的反码
111111111111111111111111111111111–a的补码
b= a>>1
111111111111111111111111111111111–a右移的结果，也就是b，但是a本身不变

2.逻辑右移（不怎么用）
    逻辑右移-右边丢弃，左边直接补0

4.位操作符 （针对整数且为2进制位,均为补码计算）

& | ^
按位与，按位或，按位异或
& – 对应的2进制位有0则为0，两个同时为1，才为1

按位或
对应的二进制位，有1则为1，两个同时为0才为0

按（二进制）位异或
对应的2进制位，相同为0，相异为1；

    面试题：不能创建临时变量(第三个变量)，实现两个正数的交换
        异或操作符
        （1.a^a = 0
        2.0^a = a）
        结论 ：异或支持交换律
        a = a^b;
        b = a^b;
        a = a^b;
        异或虽好，不要贪杯（同时递归虽好，不要贪杯）
        1.可读性差
        2.效率不如使用临时变量的方法
        3.只能针对整数的交换

5.赋值操作符

赋值操作符是一个很棒的操作符，它可以让你得到一个你之前不满意的值，
也就是你可以重新赋值
好处：可以连续赋值
a= x = y+1 ; 也是从右到左开始赋值
但这种方法不易于理解，不易于调试
等同于：
x = y+1;
a = x;

6.单目操作符

1.+= 2. -=3. *= 4. /= 5. %= 6. >>= 7. <<=

7.关系操作符

操作符有两个操作数，叫双目操作符,比如 1+3，+号为双目操作符，同理，只有一个操作数，叫单目操作符
!:逻辑反操作
-：负值
+：正值
&：取地址
&地址
常量字符串产生的就是常量的地址
“abcdef”-- 本身就是地址，不需要取地址
int main()
{
int a = 10;
int* pa = &a;
//pa里面存了a的地址
//通过解引用pa，找到a的地址
//pa 等价于 a
printf(“%d\n”, pa);
printf(“%p”, pa);
}
int main()
{
//(int)0x0012ff40;//编译不会报错，但是这是非法的
//强行访问不属于自己的地址
return 0;
}
sizeof：操作数的类型长度（以字节为单位）
sizeof - 是关键字，也是操作符
功能是计算大小
函数调用的时候，要写（）
但是sizeof使用的时候，可以省略（），说明sizeof不是函数
int main()
{
int a = 10;
printf(“%d\n”, sizeof(a));
printf(“%d\n”, sizeof a );//这样写也可行
printf(“%d\n”, sizeof(int));//如果是变量名，可以省略括号，但是如果是类型，不能省
int arr[10] = { 0 };
printf(“%d\n”, sizeof(arr));
printf(“%d\n”, sizeof arr );
printf(“%d\n”, sizeof(int[10]));
int a = 10;
short s = 5;
printf(“%d\n”, sizeof(s = a + 3));
在编译期间，a+3是int类型，但是是由s类型说了算
编译完这行代码，就已经确定了s是short类型，且s为5，无法更改
printf(“%d\n”, s);
2 5
原因是sizeof内部的表达式是不参与计算的！！
最终是s说了算，s还是short类型，s还是5

~：对一个数的二进制按位取反（包括符号位）
    ~  按位取反（二进制数）（只能针对整数）
    a = 0;
     //11111111111111111111111111111111 -- ~a的补码
     打印出来要变成原码，但是在计算机存储中仍然是补码
    //10000000000000000000000000000001  --~a的原码
    打印出来就是  -1

--：前置，后置--
++：前置，后置++
*：间接访问操作符（解引用操作符）
（类型）：强制类型转化
    
        补充：
            布尔类型：
            C99及以后引入的
                布尔类型就是用来表示真假的类型 --  _Bool
                只有true 和false 的赋值
                #include
                _Bool is_leap_year(int y)
                {
                    if ( ((y % 4 == 0) && (y % 100 != 0) ) || (y % 400 == 0))
                    {
                        return true;

                    }
                    else
                    {
                        return false;

                    }

                }
                int main()
                {
                    _Bool flag = true;//false-- 不打印hehe
                    if (flag)
                    {
                        printf("hehe\n");

                    }

                }