C语言——H/操作符详解

一、操作符的分类

算术操作符：+ 、- 、* 、/ 、%；

移位操作符：<> ;

位操作符：&、|、 ^、~ ;

赋值操作符：= 、+= 、 -= 、 *= 、 /= 、%= 、<>= 、&= 、|= 、^=

单目操作符： ！、++、–、&、*、+、-、~ 、sizeof、(强制类型转换)；

关系操作符: > 、>= 、< 、<= 、 == 、 != ；

逻辑操作符： && 、||；

条件操作符： ? : ；

逗号表达式： , ；

下标引用： [ ] ；

函数调用： ( ) ；

结构成员访问： . 、->

二、二进制和进制转换

2进制、8进制、10进制、16进制是数值的不同表示形式⽽已。

比如：数值15的各种进制的表示形式：15的2进制：111115的8进制：1715的10进制：1515的16进制：F二进制：逢二进一（0~1）基数为2，数值部分用两个不同的数字0、1来表示八进制：逢八进一（0~7）//0开头就是八进制数字基数为10，数值部分用0、1、2、3、4、5、6、7来表示十进制：逢十进一（0~9）基数为10，数值部分用0、1、2、3、4、5、6、7、8、9来表示十六进制：逢十六进一（0~15）//0x开头表示16进制数字基数是16，有十六种数字符号，除了在十进制中的0至9外，还另外用6个英文字母A、B、C、D、E、F来表示十进制数的10至15。

我们重点介绍⼀下⼆进制：

在2进制中：
• 2进制中满2进1
• 2进制的数字每⼀位都是0~1的数字组成

十进制中：
• 10进制中满10进1
• 10进制的数字每⼀位都是0~9的数字组成

1、2进制转10进制

例：1101=1*2^0+0*2^1+1*2^2+1*2^3

2、10进制转2进制数字

短除法：

3、2进制转8进制

如：2进制的01101011，换成8进制：0153，0开头的数字，会被当做8进制。

4、2进制转16进制

如：2进制的01101011，换成16进制：0x6b，16进制表⽰的时候前⾯加0x。

5、权重

任何一个进制数都可以转换为10进制：……+数*进制数的位数次幂+数*进制数位数次幂（次幂从0开始）

三、原码、反码、补码

1、概念

整数的2进制表示方法有三种，即原码、反码和补码；

有符号整数的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当做符号位，剩余的都是数值位。符号位都是⽤0表示“正”，⽤1表示“负”。

2、表示方法

正整数：原、反、补码都相同；
负整数表示方法：
原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码；
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码；
补码：反码+1就得到补码。
补码得到原码也是可以使用：符号位不变，取反，+1的操作。

对于整形来说：数据存放内存中其实存放的是补码。在计算机系统中，数值⼀律用补码来表示和存储。原因在于，使⽤补码，可以将符号位和数值域统⼀处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

四、移位操作符

<> 右移操作符；

注：移位操作符的操作数只能是整数，同时对二进制的补码进行操作。

1、左移操作符

移位规则：左边抛弃、右边补0

10存放在整型变量中，占4个字节所以就是32个bit位。

#include int main(){int num = 10;int n = num << 1;printf("n= %d\n", n);printf("num= %d\n", num);return 0;}

2、右移操作符

移位规则：

1.逻辑右移：左边用0填充，右边丢弃；
2.算术右移：左边用原该值的符号位填充，右边丢弃（大部分编译环境都是算术右移）。

#include int main(){int num = -1;int n = num >> 1;printf("n= %d\n", n);printf("num= %d\n", num);return 0;}

逻辑右移：

算术右移：

警告：对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：

int num = 10;num>>-1;//error

五、位操作符：&、|、^、~

//对二进制数进行操作运算& //按位与：只要有0就是0，两个同时为1才为1；| //按位或：只要有1就是1，两个同时为0才是0；^ //按位异或：相同为0，相异为1；~ //按位取反：所有数值取反。

注：1、他们的操作数必须是整数，同时对二进制的补码进行操作。

2、先对补码操作，然后原码输出。

#include int main(){int num1 = -3;int num2 = 5;printf("%d\n", num1 & num2);//-3的原码：10000000000000000000000000000011//-3的补码：11111111111111111111111111111101//5的原码：00000000000000000000000000000101//5的补码：00000000000000000000000000000101//num1 & num2的补码：00000000000000000000000000000101//num1 & num2的原码：00000000000000000000000000000101printf("%d\n", num1 | num2);printf("%d\n", num1 ^ num2);printf("%d\n", ~0);return 0;}

练习1：按位异或^

⼀道变态的⾯试题：不能创建临时变量（第三个变量），实现两个整数的交换

#include 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;}//异或操作符的特点：//a^a=0//0^a=a//且同时支持交换律三个进行异或时

练习2：按位与&

编写代码实现：求⼀个整数存储在内存中的⼆进制中1的个数

参考代码：//⽅法1：拿掉1计算include int main(){int num = 10;//unsigned int num(就是为了方便解决数字为负数的情况)int count = 0;//计数while (num)//不接收负数{if (num % 2 == 1)count++;num = num / 2;}printf("⼆进制中1的个数 = %d\n", count);return 0;}//思考这样的实现⽅式有没有问题？//⽅法2：#include 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：拿掉1计算#include int main(){int num = -1;int i = 0;int count = 0;//计数while (num){count++;num = num & (num - 1);//去掉最右边的1}printf("⼆进制中1的个数 = %d\n", count);return 0;}//a & 1 = 1 就说明二进制中最低位是1//a & 1 = 0 就说明二进制中最低位是0

练习3：按位或 |

⼆进制位置换0或者置换1
编写代码将13⼆进制序列的第5位修改为1，然后再改回0

13的2进制序列： 00000000000000000000000000001101将第5位置为1后：00000000000000000000000000011101将第5位再置为0：00000000000000000000000000001101

参考代码

#include int main(){int a = 13;a = a | (1 << 4);printf("a = %d\n", a);a = a & ~(1 << 4);printf("a = %d\n", a);return 0;}

六、单目操作符

！、++、–、&、*、+、-、~ 、sizeof、(强制类型转换)
单⽬操作符的特点是只有⼀个操作数，在单⽬操作符中只有&和*没有介绍，这2个操作符，我们放在学习指针的时候学习。

sizeof 运算时可以去掉括号所以不是函数！！！

七、逗号表达式

1 exp1, exp2, exp3, …expN

逗号表达式，就是⽤逗号隔开的多个表达式。
逗号表达式，从左向右依次执⾏。整个表达式的结果是最后⼀个表达式的结果。

//代码1int a = 1;int b = 2;int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式c是多少？//代码2if (a = b + 1, c = a / 2, d > 0)//代码3a = get_val();count_val(a);while (a > 0){//业务处理a = get_val();count_val(a);} 如果使⽤逗号表达式，改写：while (a = get_val(), count_val(a), a > 0){//业务处理}

八、下标访问[ ]、函数调用( )

1、[ ]下标引用操作符

操作数：⼀个数组名 + ⼀个索引值

int arr[10];//创建数组arr[9] = 10;//实⽤下标引⽤操作符。[ ]的两个操作数是arr和9

2、函数调用操作符

接受⼀个或者多个操作数：第⼀个操作数是函数名，剩余的操作数就是传递给函数的参数

#include void test1(){printf("hehe\n");}void test2(const char* str){printf("%s\n", str);}int main(){test1(); //这⾥的()就是作为函数调⽤操作符。test2("hello bit.");//这⾥的()就是函数调⽤操作符。return 0;}

九、结构成员访问操作符

1、结构体

C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类
型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不⾏的。描述⼀个学⽣需要名字、年龄、学号、⾝⾼、体重等；描述⼀本书需要作者、出版社、定价等。C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：
标量、数组、指针，甚⾄是其他结构体。

2、结构的声明

struct tag{member-list;}variable-list;

描述⼀个学生：

struct Stu{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号}; //分号不能丢

3、结构体变量的定义和初始化

//代码1：变量的定义struct Point{int x;int y;}p1; //声明类型的同时定义全局变量p1struct Point p2; //定义结构体局部变量p2//代码2:初始化struct Point p3 = { 10, 20 };struct Stu //类型声明{ char name[15]; //名字int age; //年龄};struct Stu s1 = { "zhangsan", 20 }; //初始化struct Stu s2 = { .age = 20, .name = "lisi" };//指定顺序初始化//代码3struct Node{int data;struct Point p;struct Node* next;}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化

4、结构成员访问操作符

9.4.1 结构体成员的直接访问
结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。如下所示：

#include struct Point{int x;int y;}p = { 1,2 };int main(){printf("x: %d y: %d\n", p.x, p.y);return 0;}

使用⽅式：结构体变量 . 成员名

9.4.2结构体成员的间接访问
有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针。

#include struct Point{int x;int y;};int main(){struct Point p = { 3, 4 };struct Point* ptr = &p;ptr->x = 10;ptr->y = 20;printf("x = %d y = %d\n", ptr->x, ptr->y);return 0;}

使⽤⽅式：结构体指针->成员名
综合举例：

#include #include struct Stu{char name[15];//名字int age; //年龄};void print_stu(struct Stu s){printf("%s %d\n", s.name, s.age);}void set_stu(struct Stu* ps){strcpy(ps->name, "李四");ps->age = 28;}int main(){struct Stu s = { "张三", 20 };print_stu(s);set_stu(&s);print_stu(s);return 0;}

十、操作符的属性：优先级、结合性

C语⾔的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。

1、优先级

优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不⼀样的。

 3 + 4 * 5;

上面示例中，表达式 3 + 4 * 5 ⾥⾯既有加法运算符（ + ），⼜有乘法运算符（ * ）。由于乘法
的优先级⾼于加法，所以会先计算 4 * 5 ，⽽不是先计算 3 + 4 。

2、结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（ = ）。

 5 * 6 / 2;

上面示例中， * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算 5 * 6 ，
再计算 6 / 2 。
运算符的优先级顺序很多，下⾯是部分运算符的优先级顺序（按照优先级从高到低排列），建议⼤概记住这些操作符的优先级就行，其他操作符在使⽤的时候查看下⾯表格就可以了。
• 圆括号（ () ）
• 自增运算符（ ++ ），自减运算符（ — ）
• 单⽬运算符（ + 和 – ）
• 乘法（ * ），除法（ / ）
• 加法（ + ），减法（ – ）
• 关系运算符（ 等）
• 赋值运算符（ = ）
由于圆括号的优先级最⾼，可以使⽤它改变其他运算符的优先级

参考：https://zh.cppreference.com/w/c/language/operator_precedence

十 一、表达式求值

1、整型提升

C语⾔中整型算术运算总是⾄少以缺省（忽略）整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。（因为其存储方式是以ASCII的形式存储的）
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度⼀般就是 int 的字节长度，同时也是CPU的通⽤寄存器的长度。因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通⽤CPU（general-purposeCPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于 int 长度的整型值，都必须先转换为 int 或 unsigned int，然后才能送⼊CPU去执行运算。

//实例1char a,b,c;...a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
如何进行整体提升呢？
1. 有符号整数提升是按照变量的数据类型的符号位来提升的；
2. ⽆符号整数提升，高位补0；

//负数的整形提升char c1 = -1;变量c1的⼆进制位(补码)中只有8个⽐特位：1111111因为 char 为有符号的 char所以整形提升的时候，⾼位补充符号位，即为1提升之后的结果是：11111111111111111111111111111111//正数的整形提升char c2 = 1;变量c2的⼆进制位(补码)中只有8个⽐特位：00000001因为 char 为有符号的 char所以整形提升的时候，⾼位补充符号位，即为0提升之后的结果是：00000000000000000000000000000001//⽆符号整形提升，⾼位补0

2、算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中⼀个操作数的转换为另⼀个操作数的类型，否则操作就⽆法进行。下面的层次体系称为寻常算术转换

long doubledoublefloatunsigned long intlong intunsigned intint

如果某个操作数的类型在上⾯这个列表中排名靠后，那么⾸先要转换为另外⼀个操作数的类型后执⾏运算。

3、总结

即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的计算路径，那这个表达式就是存在潜在⻛险的，建议不要写出特别负责的表达式。

动力不够，鸡汤来凑！