1. 操作符的分类
- 算术操作符：+ 、- 、* 、/ 、%
- 移位操作符：<< 、>>
- 位操作符：& 、| 、^
- 赋值操作符：= 、+= 、-= 、*= 、/= 、%= 、<<= 、>>= 、&= 、|= 、^=
- 单目操作符：！、++ 、-- 、& 、* 、+ 、- 、~ 、sizeof、（类型）
- 关系操作符：> 、>= 、< 、<= 、== 、!=
- 逻辑操作符：&& 、||
- 条件操作符：？、：
- 逗号表达式：，
- 下标引用：[ ]
- 函数调用：( )
- 结构成员访问：. 、->
在以往的文章中，已经说明过算术操作符、赋值操作符、逻辑操作符、条件操作符和部分单目操作符，今天继续说明一部分，操作符中有一些操作符与二进制有关，所以我们要先讲一些前置知识。
2. 前置知识
2.1 二进制与进制转换
2.1.1 二进制
首先我们从10进制说起，10进制是我们生活中经常使用的，众所周知：
- 10进制中满10进1
- 10进制的数字每一位都是0~9的数字组成
其实2进制也是一样的：
- 2进制中满2进1
- 2进制的数字每一位都是0~1的数字组成
例：
1010是二进制数字
2.1.2 进制转换
2.1.2.1 二进制转十进制
10进制的123表示的值是一百二十三，为什么是这个值呢？那是因为10进制中的每一位都是有权重的，如下图：
我们拿2进制数1101举例，2进制和10进制是类似的，如下图：
2.1.2.2 十进制转二进制
我们拿10进制数125举例：
2.1.2.3 二进制转八进制
8进制的数字每⼀位是0~7的，把0~7各自写成2进制，最多有3个2进制位就足够了。
比如7的2进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算一个8进制位，剩余不够3个2进制位的直接换算。
例：
2进制的01101011换成8进制为0153，0开头的数字，会被当做8进制
2.1.2.4 二进制转十六进制
16进制的数字是0~9、a~f的，把0~9、a~f的数字，各自写成2进制，最多有4个2进制位就足够了。
比如 f 的二进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算⼀个16进制位，剩余不够4个⼆进制位的直接换算。
例：
2进制的01101011，换成16进制：0x6b，0x开头的数字，会被当成16进制
2.2 原码、反码、补码
-
整数的2进制表示方法有三种，即原码、反码和补码。
-
有符号整数的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位被当做符号位，剩余的都是数值位。
-
符号位都是用0表示“正”，用1表示“负”。
-
正整数的原，反、补码都相同。
负整数的三种表示方法各不相同。
原码：直接将数值按照正负数的形式翻译成⼆进制。
反码：将原码的符号位不变，其他位依次按位取反。
补码：反码+1。 -
补码得到原码也是可以使用：取反，+1的操作。
注：
对于整形来说：存放在内存中的数据其实是补码。
为什么呢？
在计算机系统中，数值一律用补码来表示和存储。
使用补码，可以将符号位和数值位统⼀处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
3. 操作符解析
3.1 移位操作符
<<: 左移操作符
>> :右移操作符
移位操作符移的是内存中补码的二进制位
3.1.1 左移操作符
移位规则：左边抛弃、右边补0
#include<stdio.h>
int main(){
int num = 0;
int n = num<<1;
printf("n = %d",n);
printf("num = %d",num);
return 0;
}
运算过程如下：
3.1.2 右移操作符
移位规则：右移运算分两种：
- 逻辑右移：左边用0填充，右边丢弃
- 算术右移：左边用原该值的符号位填充，右边丢弃
#include<stdio.h>
int main(){
int num = 0;
int n = num>>1;
printf("n = %d",n);
printf("num = %d",num);
return 0;
}
逻辑右移运算如下：
算术右移运算如下：
注：
对于移位操作符，不要移动负数位。这个是标准未定义的。例如：num>>-1。
3.2 位操作符
3.2.1 位操作符说明
位操作符有：
- &：按位与
- |：按位或
- ^：按位异或
- ~：按位取反
注：
他们的操作数必须是整数，运算过程为（补码）二进制数位逐位计算。计算出来的也是补码。
代码及运算过程如下：
#include<stdio.h>
int main(){
int num1 = -3;
// 10000000000000000000000000000011
// 11111111111111111111111111111100
// 11111111111111111111111111111101 - 补码
int num2 = 5;
// 00000000000000000000000000000101 - 补码
printf("%d\n", num1 & num2); // 对应二进制位有0则为0，两个同时为1才是1
// 11111111111111111111111111111101
// 00000000000000000000000000000101
// 00000000000000000000000000000101 - 正整数补码，结果是 5
printf("%d\n", num1 | num2); // 对应二进制位有1则为1，两个同时为0才是0
// 11111111111111111111111111111101
// 10000000000000000000000000000101
// 11111111111111111111111111111101 - 负整数补码，需要转换为原码得出结果
// 10000000000000000000000000000011 - 负整数原码，结果是 -3
printf("%d\n", num1 ^ num2); // 对应二进制位相异为1，相同为0
// 11111111111111111111111111111101
// 00000000000000000000000000000101
// 11111111111111111111111111111000 - 负整数补码，需转换为原码得出结果
// 10000000000000000000000000001000 - 负整数原码，结果为 -8
printf("%d\n", ~0);
// 00000000000000000000000000000000
//取反后11111111111111111111111111111111 - 负整数补码，需要转换为原码
// 10000000000000000000000000000001 - 负整数原码，结果为 -1
return 0;
}
3.2.2 位操作符应用和解析
3.2.2.1 整数交换
题目描述：
不能创建临时变量（第三个变量），实现两个整数的交换。代码实现如下：
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a = %d b = %d\n", a, b);
return 0;
}
首先，我们若想理解这段代码，必须知道抑或运算的几个性质：
- 任何数与0进行抑或运算，结果仍然是原来的数
- 任何数与其自身进行抑或运算，结果为0
- 抑或运算满足交换律和结合律
在明白这几个性质的基础上，我们需要截出上面关于a和b运算的代码段，并作出解析：
a = a^b;// 1式
b = a^b; // 2式
// 将1式迭代进2式得：
// b = (a ^ b) ^ b // 4式
// b = a ^ b ^ b
// b = a ^ 0
// b = a
a = a^b; // 3 式
// 将1式和4式 迭代进3式得：
// a = a ^ b ^ (a ^ b) ^ b
// a = a ^ a ^ b ^ b ^ b
// a = b
3.2.2.2 1的个数
题目描述：
求一个整数存储在内存中的二进制中1的个数。代码实现如下：
//⽅法1
#include <stdio.h>
int main()
{
int num = 10;
int count = 0;//计数
while(num)
{
if(num%2 == 1)
count ++;
num = num / 2; // 每次 / 2,二进制中的1就向右移一位
}
printf("⼆进制中1的个数 = %d\n", count);
return 0;
}
//⽅法2：
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;//计数
for(i=0; i<32; i++)
{
if( num & (1 << i) )
count++;
}
printf("⼆进制中1的个数 = %d\n",count);
return 0;
}
//思考还能不能更加优化，这⾥必须循环32次的。
//⽅法3：
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;//计数
while(num)
{
count ++;
num = num&(num - 1);
}
printf("⼆进制中1的个数 = %d\n",count);
return 0;
}
3.2.2.3 二进制位置0或者置1
题目描述：
编写代码将13⼆进制序列的第5位修改为1，然后再改回0。效果如下：
13的2进制序列 ： 00000000000000000000000000001101
将第5位置为1后：00000000000000000000000000011101
将第5位再置为0：00000000000000000000000000001101
实现代码如下：
#include <stdio.h>
int main()
{
int a = 13;
a = a | (1<<4);
// 00000000000000000000000000001101 - a
// 00000000000000000000000000010000 - 1<<4
// 00000000000000000000000000011101
printf("a = %d\n", a);
a = a & ~(1<<4);
// 00000000000000000000000000011101 - 置1后的a
// 00000000000000000000000000010000 - 1<<4
// 01111111111111111111111111101111 - ~(1<<4)
// 00000000000000000000000000001101
printf("a = %d\n", a);
return 0;
}
3.3 单目操作符
| 操作符 | 操作符作用 |
|---|---|
| ！ | 逻辑反操作 |
| - | 负值 |
| + | 正值 |
| & | 取地址 |
| sizeof | 计算给定类型或表达式的大小（字节） |
| ~ | 二进制按位取反 |
| - - | 前置、后置- - |
| ++ | 前置、后置++ |
| * | 间接访问（解引用）操作符 |
| （类型） | 强制类型转换 |
3.4 逗号表达式
表示形式：
exp1，exp2，exp3，……，expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左到右依次执行。整个表达式的结果是最后一个子表达式的结果。
逗号表达式应用代码如下：
// 代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？
// 代码2
if (a =b + 1, c=a / 2, d > 0)
// 代码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)
{
//业务处理
}
3.5 下标引用操作符
下标引用操作符：[ ]
操作数：一个数组名+一个索引值（下标）。
应用场景如下：
int arr[10];// 创建数组
arr[2] = 9;// 应用下标引用操作符
// []的两个操作数是arr和2
3.6 函数调用操作符
函数调用操作符：( )
接受一个或多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
应用场景如下：
#include <stdio.h>
void test(const char *str)
{
printf("%s\n", str);
}
int main()
{
test("haha");//这里的()就是函数调用操作符
return 0;
}
3.7 结构成员访问操作符
3.7.1 结构体成员的直接访问
结构体成员的直接访问是通过点操作符（.）访问的。
接受两个操作数：结构体变量、成员名。
使用方式：结构体变量.成员名
应用场景如下：
#include <stdio.h>
struct Point
{
int x;
int y;
}p = {1,2};
int main()
{
printf("x: %d y: %d\n", p.x, p.y);
return 0;
}
3.7.2 结构体成员的间接访问
有时候我们得到的不是⼀个结构体变量，而是得到了⼀个指向结构体的指针。这个时候我们就可以用（->）来间接访问结构体成员。
接受两个操作数：结构体指针、成员名。
使用方式：结构体指针->成员名
如下方代码：
#include <stdio.h>
struct Point
{
int x;
int y;
};
int main()
{
struct Point p = {3, 4};
struct Point *ptr = &p;
printf("x = %d y = %d\n", ptr->x, ptr->y);
return 0;
}
4. 操作符属性
4.1 优先级
优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不⼀样的。
例：
1 + 2 * 3
上方示例中，表达式1 + 2 * 3既有有加法运算符（+），⼜有乘法运算符（*）。由于乘法运算符的优先级高于加法，所以会先计算2 * 3。
运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从高到低排列）：
- 圆括号（
()） - 自增运算符（
++），自减运算符（--） - 单目运算符（
+和-） - 乘法
*），除法（/） - 加法（
+），减法（-） - 关系运算符（
<、>等） - 赋值运算符（
=）
更多运算符优先级参考：添加链接描述
4.2 结合性
如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。⼤部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（=）。
例：
4 * 5 / 2
上面示例中，* 和/的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算 5 * 6 ，再计算 / 2。
注：
即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的计算路径，那这个表达式就是存在潜在风险的，建议不要写出特别复杂的表达式。例如：c + --c
5. 表达式求值
5.1 整型提升
C语⾔中整型算术运算总是至少以缺省（默认）整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度⼀般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
实例：
char a,b,c;
a = b + c;
执行细节：b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
那么问题来了，如何进行整型提升呢？
- 有符号整数提升是按照变量的数据类型的符号位来提升的，高位补其符号位
- 无符号整数提升，高位补0
5.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中⼀个操作数的转换为另⼀个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换：
long double
double
float
unsigned long int
long int
unsigned int
int
类型提升规则：如果某个操作数的类型在上面这个列表中排名靠后，那么首先要转换为另外⼀个操作数的类型后执行运算。
扫一扫
1681
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
