目录

算数操作符

位移操作符

<< 左移操作符

>>右移操作符

位操作符

& 按位与

| 按位或

^ 按位异或

位移操作符以及位操作符的实战运用

不能创建临时变量（第三个变量），实现两个数的交换

统计二进制中1的个数

两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同

赋值操作符

复合赋值符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

隐式类型转换

算术转换

操作符的属性

算数操作符

• • • / %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

位移操作符
<< 左移操作符
>>右移操作符
小提示：左右容易搞反的话只要记着箭头指向的位置就行了，箭头指向哪边就是往哪里移）

注：移位操作符的操作数只能是整数
<< 左移操作符
移位规则

将其二进制位向左移动移位，然后右边补0

int main()
{

int a = 10;    //00000000000000000000000000001010
int b = a << 1;//00000000000000000000000000010100
printf("a=%d,b=%d",a, b);
return 0;

}
这是我们的移位结果，其作用相当于将a乘以2。

值得我们注意的是虽然我们对a进行了移位操作但是a本身没有变我们可以看到a的值还是10。

右移操作符
移位规则：
首先右移运算分两种：

1. 逻辑移位 ： 左边用0填充，右边丢弃。
2. 算术移位 ： 左边用原该值的符号位填充，右边丢弃。

具体是左移还是右移要看具体的机器，在我们的VS2022中是用的算数右移。

int main()
{

int a = -10;   //1111 1111 1111 1111 1111 1111 1111 0110
int b = a >> 1;//1111 1111 1111 1111 1111 1111 1111 1011
printf("a=%d,b=%d", a, b);
return 0;

}

这里我们可以看到右移操作相当于除2的功能（当是负数是会在除2的基础上-1）。

注意：对于移位运算符，不要移动负数位，这个是标准未定义的。
位操作符
& // 按位与
| // 按位或
^ // 按位异或
注：他们的操作数必须是整数。
& 按位与
运算规则：按位于的运算法则就是在两个数的二进制表示中如果有一个是0那么其结果就是0，只有两个对应位全是1，其结果才是1。

| 按位或
运算规则：按位于的运算法则就是在两个数的二进制表示中如果有一个是1那么其结果就是1，只有两个对应位全是0，其结果才是0。

^ 按位异或
运算规则：按位于的运算法则就是在两个数的二进制表示中如果两个对应位相同则为0，对应位不同则为1。

int main()
{

int a = 1;//00000000000000000000000000000001
int b = 2;//00000000000000000000000000000010
int c = 0;
printf("%d\n", a & b); //00000000000000000000000000000000
printf("%d\n", a | b); //00000000000000000000000000000011
printf("%d\n", a ^ b); //00000000000000000000000000000011
return 0;

}

位移操作符以及位操作符的实战运用
不能创建临时变量（第三个变量），实现两个数的交换
int main()
{

int a = 10;//00001010
int b = 20;//00010100
printf("交换前：a=%d,b=%d\n", a, b);
a = a ^ b;// 00011110
b = a ^ b;// 00001010
a = a ^ b;// 00010100
printf("交换后：a=%d,b=%d\n", a, b);
return 0;

}

统计二进制中1的个数
int main()
{

int a = 0;
int count = 0;
int flag = 1;
printf("请输入：");
scanf("%d", &a);
while (flag<=32)
{
    if (((a >> flag) & 1) == 1)
        count++;
    flag++;
}
printf("%d的二进制形式中1的个数为%d", a, count);
return 0;

}

两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同
int main()
{

int a = 0;
int b = 0;
int count = 0;
int flag = 1;
printf("请输入：");
scanf("%d %d", &a, &b);
while (flag <= 32)
{
    if (((a >> flag) & 1) != ((b >> flag) & 1))
        count++;
    flag++;
}
printf("共%d个bit位不同", count);
return 0;

}

赋值操作符
赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。
int main()
{

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;
//赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20; a = x = y+1;//连续赋值
//这样的代码感觉怎么样？
//那同样的语义，你看看：
x = y+1; a = x;
//这样的写法是不是更加清晰爽朗而且易于调试。

return 0;

}

复合赋值符

+=

*=
/=
%=

=
<<=
&=
|=
^=
这些运算符都可以写成复合的效果
int x = 10 ;
x = x + 10 ;
x += 10 ; // 复合赋值
// 其他运算符一样的道理。这样写更加简洁。
单目操作符
! 逻辑反操作

• 负值
• 正值

& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置 --
++ 前置、后置 ++

• 间接访问操作符 ( 解引用操作符 )

( 类型 ) 强制类型转换
int main()
{

int a = -10;
int* p = NULL;
printf("%d\n", !2);
printf("%d\n", !0);
a = -a;
p = &a;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//这样写行不行？
//printf("%d\n", sizeof int);//这样写行不行？
return 0;

}
这里我们可以看到当sizeof后面是类型的时候则必须加上括号。

在这里我们讲一下按位取反的运用~
有两个问题一个是把一个数字的二进制的n位置为1和把一个数字的二进制的n位置为0
int main()
{

int a = 10;
int n = 0;
scanf("%d", &n);
//把a的第n位置为1
a = a | (1 << (n-1));
printf("a=%d\n", a);

//把a的第n位置为0
a = a & ~(1 << (n - 1));
printf("a=%d\n", a);

//00000000000000000000000000001010
//00000000000000000000000000010000
//1<<2;
//00000000000000000000000000011010
//11111111111111111111111111101111
//00000000000000000000000000010000
//00000000000000000000000000001010
return 0;

}

这里我们刚好结合着按位与和按位或解决了这个问题。

下面给大家简单介绍一个易错点

int main()
{

short s = 10;
int a = 2;
s = a + 5;

printf("%zu\n", sizeof(s = a + 5));

printf("%d\n", s);
return 0;

}
上面程序的结果是什么呢？（%zu是输出的无符号整型）

我们可以看到是2 7，s是short所以占两个字节但是s不是+5了吗为什么不是12呢？

因为sizeof()括号里面的表达式我们是不计算的。

关系操作符

=
<
<=
!= 用于测试 “ 不相等 ”
== 用于测试 “ 相等 ”
逻辑操作符
&& 逻辑与
|| 逻辑或

include <stdio.h>

int main()
{

int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0; }

//程序输出的结果是什么？

这里为什么只有a变了，其他的为啥没有变化呢，这里是因为当我们a=0通过&&的判断后面无论是真还是假，这个整体的结果都是假，所以后面的自增操作没有进行。

条件操作符
exp1 ? exp2 : exp3
如果问号前的表达式的值为真，那么整个表达式的结果就是exp2,否则就是exp3。
逗号表达式
exp1 , exp2 , exp3 , …
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
//代码3 a = get_val();
count_val(a);
while (a > 0)
{

a = get_val();
count_val(a);

}
这里我们会觉得代码有些冗余

while (a = get_val(), count_val(a), a>0) {

     //业务处理

}
改成这样大家会发现代码明显就精简了一些。

隐式类型转换
C 的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为 整型 提升 。
表达式的整型运算要在 CPU 的相应运算器件内执行， CPU 内整型运算器 (ALU) 的操作数的字节长度 一般就是int 的字节长度，同时也是 CPU 的通用寄存器的长度。 因此，即使两个char 类型的相加，在 CPU 执行时实际上也要先转换为 CPU 内整型操作数的标准长度。
通用 CPU （ general-purpose CPU ）是难以直接实现两个 8 比特字节直接相加运算（虽然机器指令 中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int 长度的整型值，都必须先转 换为int 或 unsigned int ，然后才能送入 CPU 去执行运算。
//实例1
char a,b,c;
...
a = b + c;
b 和 c 的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
如何进行整体提升呢？
整形提升是按照变量的数据类型的符号位来提升的
// 负数的整形提升
char c1 = - 1 ;
变量 c1 的二进制位 ( 补码 ) 中只有 8 个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为 1
提升之后的结果是：
11111111111111111111111111111111
// 正数的整形提升
char c2 = 1 ;
变量 c2 的二进制位 ( 补码 ) 中只有 8 个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为 0
提升之后的结果是：
00000000000000000000000000000001
// 无符号整形提升，高位补 0
int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if(a== 0xb6)
printf("a");
if(b== 0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0; }

这里的char和short都是小于4个字节所以要进行整型提升，所以就不相等。
int main()
{

char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;

}

这里的c在+-操作符之后也会整型提升，所以都是4个字节。
算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为寻常算术转换 。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运 算。
警告：
但是算术转换要合理，要不然会有一些潜在的问题，如精度会丢失。
操作符的属性
复杂表达式的求值有三个影响的因素。

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级

问题表达式
int fun()
{

static int count = 1;
return ++count;

}
int main()
{

int answer;
answer = fun() - fun() * fun();
printf("%d\n", answer);//输出多少？
return 0;

}
虽然我们知道执行的顺序先*后-但是我们不知道到底哪个fun先准备的，所以这是一个问题的表达式，在不同的编译器下结果是不一样的。
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0; }
这段代码中的第一个 + 在执行的时候，第三个 ++ 是否执行，这个是不确定的，因为依靠操作符的优先级 和结合性是无法决定第一个 + 和第 三个前置 ++ 的先后顺序。
总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题 的。