C语言——最强版操作符详解

1. 操作符的分类

• 算术操作符： + 、- 、* 、/ 、%
• 移位操作符: << >>
• 位操作符: & | ^
• 赋值操作符: = 、+= 、 -= 、 * = 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
• 单⽬操作符： ！、++、–、&、*、+、-、~ 、sizeof、(类型)
• 关系操作符: > 、>= 、< 、<= 、 == 、 !=
• 逻辑操作符： && 、||
• 条件操作符： ? :
• 逗号表达式： ,
• 下标引⽤： []
• 函数调⽤： ()
• 结构成员访问： . 、->

2. ⼆进制和进制转换

首先重点介绍一下二进制：

⾸先我们还是得从10进制讲起，其实10进制是我们⽣活中经常使⽤的，我们已经形成了很多尝试：
• 10进制中满10进1
• 10进制的数字每⼀位都是0~9的数字组成

其实⼆进制也是⼀样的
• 2进制中满2进1
• 2进制的数字每⼀位都是0~1的数字组成，那么 1101 就是⼆进制的数字了。

举个例子：15的各种进制的表现形式：

15的2进制：1111
15的8进制：17
15的10进制：15
15的16进制：F
//16进制的数值之前写：0x
//8进制的数值之前写:0

2.1 2进制转10进制

首先我们了解到其实10进制的每⼀位是有权重的，10进制的数字从右向左是个位、十位、百位…，分别每⼀位的权重是 10 ^ 0, 10 ^ 1,10 ^ 2 …

2进制和10进制是类似的，只不过2进制的每⼀位的权重，从右向左是: 2 ^ 0 , 2 ^ 1 , 2 ^ 2 …

2.1.1 10进制转2进制数字

2.2 2进制转8进制和16进制

2.2.1 2进制转8进制

8进制的数字每⼀位是0_7的，07的数字，各⾃写成2进制，最多有3个2进制位就⾜够了，剩余不够3个2进制位的直接换算。如：2进制的 01101011，换成8进制：0153，0开头的数字，会被当做8进制。

2.2.2 2进制转16进制

16进制的数字每⼀位是0~9, a~f 的，0~9, a~f的数字，各⾃写成2进制，最多有4个2进制位就⾜够了，剩余不够4个⼆进制位的直接换算。如：2进制的01101011，换成16进制：0x6b，16进制表⽰的时候前⾯加 0x

3. 原码、反码、补码

当我们要把一个数转换成二进制表示是：整数的二进制中有三种表现形式（暂时不考虑浮点数）分别为原码，反码和补码。

有符号整数的三种表示方法，均有符号位和数值为两部分，二进制序列中，最高位的1位被当作符号位，剩余的都是数值位。

int 的长度为4个字节即32个bit位。

对于unsigned int 来说，没有符号位全部为数值位。

正整数的原、反、补码都相同。
负整数的三种表⽰⽅法各不相同。

原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码：反码+1就得到补码。

补码得到原码也是可以使⽤取反，+1的操作：

比如说-8：

对于整形来说：数据存放内存中其实存放的是补码。

原因在于，使⽤补码，可以将符号位和数值域统⼀处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

4. 移位操作符

<< 左移操作符
>> 右移操作符

注：移位操作符的操作数只能是整数。（并且移动的是二进制位）

4.1 左移操作符

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

int main()
{
	int a = 10;//移动的是存储在内存中的二进制位（补码）
	int b = a << 1;//向左移一位
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	return 0;
}

 int main()
{
int a = -1;
int b = a << 1;
printf("b = %d\n",b);
printf("a = %d\n",a);
return 0;
}

左移一位有乘2的效果。

4.2 右移操作符

移位规则：⾸先右移运算分两种：
1 . 逻辑右移：左边⽤0填充，右边丢弃
2 . 算术右移：左边⽤原该值的符号位填充，右边丢弃

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

右移到底采用算术右移还是逻辑右移，是取决于编译器的！通常采用的都是算术右移浮点数不能移位。

注意：对于移位运算符，不要移动负数位，这个时标准未定义的。

int a = 10;
a >> -1; //error!

5. 位操作符：&、|、^、~

& // 按位与
| // 按位或
^ // 按位异或
~ // 按位取反

& — 按（二进制）位与
&& — 逻辑与
| — 按（二进制）位或
|| —逻辑或
注：他们的操作数必须是整数。

& 按位与 :

int main()
{
int a = 6;
int b = -7;
int c = a & b;//a和b的补码的二进制序列进行运算
printf(“c = %d\n”,c);
return 0;
}

| 按位或 :

int main()
{
int a = 6;
int b = -7;
int c = a | b;
printf(“c = %d\n”,c); // 结果为-1
return 0;
}

^ 按位异或 :

int main()
{
int a = 6;
int b = -7;
int c = a ^ b;
printf(“c = %d\n”,c);
return 0;
}

~ 按位取反 :

int main()
{
int a = 0;
printf(“~a = %d\n”,~a);
return 0;
}

小tips:
&（按位与）-- 有0为0，同1为1
|（按位或）-- 有1为1，同0为0
^（按位异或）-- 相同为0，相异为1
~（按位取反）-- 不管符号位，全部取反

重点记住：
0 ^ a = a
3 ^ 3 ^ 5 = 5
3 ^ 5 ^ 3 = 5

异或是支持交换律的：
a ^ b ^ a = b
b ^ a ^ b = a

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

方法一：

int main()
{
int a = 3;
int b = 5;
printf("a = %d\n,b = %d\n",a,b);
a = a + b;
b = a - b;
a = a - b;
printf("a = %d\n,b = %d\n",a,b);
return 0;
}

方法二：

int main()
{
int a = 3;
int b = 5;
printf("a = %d\n,b = %d\n",a,b);
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a = %d\n,b = %d\n",a,b);
return 0
}

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

法1：

int count_bit_one(int n)
{
	int count = 0;
	while (n)
	{
		if ((n % 2) == 1)
			count++;
			n /= 2;
	}
	return count;
}
int main()
{
	int input = 0;
	scanf("%d", &input);
	int ret = count_bit_one(input);
	printf("%d\n", ret);
	return 0;
}

法2：
这样只能计算正整数，如果给一个负数就会出错，这里我们可以把输入的值在传参时转换成无符号整型便可解决这个问题。

我们换一种思路，是否可以不考虑正负数的问题，比如 -1：

-1：11111111 11111111 11111111 11111111
1：00000000 00000000 00000000 00000001
-1 & 1 ：00000000 00000000 00000000 00000001

若n&1 == 1则其最低位原本就是1
若n&1 == 0则其最低位原本就是0

如果想知道这个数最低位的前一位就可以使用右移符，若想知道全部，可以右移32位

看下列代码：

int count_bit_one(int num)
{
 int i = 0;
 int count = 0;
 for(i = 0; i < 32; i++)
 {
  if(((num >> i)& 1)== 1)
  {
 count++;
  }
 }
return count;
}
 
int main()
{
int input = 0;
scanf("%d",&input);
int ret = count_bit_one(input);
printf("%d",ret);
return 0;
} 

法3：
看下图思考：

可以得出结论，这个表达式执行几次，n就去掉几个1，所以 n & (n-1) 执行几次就有几个1.
看下列代码：

int count_bit_one(int x)
 
int main()
{
int input = 0;
scanf("%d",&input);
int ret = count_bit_one(input)
printf("%d\n",ret);
return 0;
}
 
int count_bit_one(int num)
{
int count = 0;
while(num)
 {
  n = n & (n - 1);
  count++;
 }
return 0;
}

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

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

执行代码如下：

int main()
{
	int n = 0;
	scanf("%d", &n);
    n = n | (1 << (n - 1));
	printf("n = %d\n", n);
	n = n & ~(1 << (n - 1));
	printf("n = %d\n", n);
	return 0;
}

写一个代码判断n是否是2的次方数：

void count_bit_one(int x)
 {
if(n &(n - 1)== 0)
printf("yes\n");
}
int main()
{
int input = 0;
scanf("%d",&input);
count_bit_one(input);
return 0;
}

6. 单⽬操作符

单⽬操作符有这些：
！、++、–、&、*、+、-、~ 、sizeof、(类型)
单⽬操作符的特点是只有⼀个操作数，在单⽬操作符中只有 & 和 * 没有介绍，这2个操作符，我们放在学习指针的时候学习。
& —— 取地址操作符
*—— 解引用操作符

7. 逗号表达式

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

int main()
{
	int a = 5;
	int b = 10;
	int c = (a > b, a = b + 5, b = a - 5, c = a+b);
	printf("%d\n", c);//结果为25
	return 0;
}

8. 下标访问[]、函数调⽤()

8.1 [ ] 下标引⽤操作符

操作数：⼀个数组名 + ⼀个索引值(下标)

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

8.2 函数调⽤操作符

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

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

int Add(int x, int y)
{
return x + y;
}
 
int main()
{
int ret = Add(3,4);  //操作数有 add,3,4
printf("%d\n"ret);  // 函数调用操作符最少一个操作数 
return 0;
}

9. 结构成员访问操作符

9.1 结构体

C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不行的。

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

9.1.1 结构的声明

struct tag //tag是自定义
{
member-list; //成员列表
}variable-list; //变量列表

struct student
{
	char name[20];
	int age;        //成员变量
	float score;
}s4,s5,s6;

struct student s3;   //全局变量
int main()
{
	int a = 0;
	struct student s1;  //局部变量
	struct student s2 = { "张三" , 20， 95.0};

	return 0;
}

9.2 结构成员访问操作符

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。
使⽤⽅式：结构体变量.成员名

#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;
}

struct Student
{
	char name[20];
	int age;       
	float score;
}s4, s5, s6;

struct Point
{
	int x;    //坐标
	int y;
}

struct Y
{
	char ch;
	struct Point P;
	int arr[10];
	double c;
};

int main()
{
	int a = 0;
	struct Student s1 = { "李四",20,97.0 };
	struct Student s2 = { "张三", 20,95.0};
	struct Point P = { 1,2 };
	struct Y y = { 'a',{10,20},{1,2,3,4,5,6,7},3.14159 };
	printf("%c\n", y.ch);
	printf("x: %d y: %d\n", y.P.x, y.P.y);  //注意大小写
	printf("%d\n", y.arr[1]);
	printf("%lf\n", y.c);
	return 0;
}

结构体成员的间接访问–可以得到一个指向结构体的指针，使⽤⽅式：结构体指针->成员名，后续我们在指针详细介绍。

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

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

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

10.1 优先级

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

1 3 + 4 * 5;

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

10.2 结合性

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

1 5 * 6 / 2;

上⾯⽰例中， * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执⾏，先计算 5 * 6 ，再计算 / 2 。

11. 表达式求值

11.1 整形提升

C语⾔中整型算术运算总是⾄少以缺省（默认）整型类型的精度来进⾏的。

为了获得这个精度，表达式中的字符和短整型操作数在使⽤之前被转换为普通整型，这种转换称为整型提升。
eg:

char a = 10;
char b = 20;
char c = a + b;

这样会发生整形提升。

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执⾏，CPU内整型运算器(ALU)的操作数的字节⻓度⼀般就是int的字节⻓度，同时也是CPU的通⽤寄存器的⻓度。因此，即使两个char类型的相加，在CPU执⾏时实际上也要先转换为CPU内整型操作数的标准⻓度。通⽤CPU（general-purpose CPU）是难以直接实现两个8⽐特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种⻓度可能⼩于int⻓度的整型值，都必须先转换为int或unsigned int，然后才能送⼊CPU去执⾏运算。

如何进⾏整体提升呢？

1 . 有符号整数提升是按照变量的数据类型的符号位来提升的
2 . ⽆符号整数提升，⾼位补0

因为 char 为有符号的 char，所以整形提升的时候，⾼位补充符号位，即为0。

结果为什么为-106 ，而不是150，原因在于：

11.2 算术转换

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

11.3 问题表达式解析

11.3.1 表达式1

//表达式的求值部分由操作符的优先级决定。
//表达式1
ab + cd + e*f

表达式1在计算的时候，由于 * ⽐ + 的优先级⾼，只能保证， * 的计算是⽐ + 早，但是优先级并不能决定第三个 * ⽐第⼀个 + 早执⾏。

所以表达式的计算机顺序就可能是：

1 . a * b
2.c * d
3.ab + cd
4.e * f
5.a * b + c * d + e * f

或者：

1 . a * b
2 . c * d
3 . e * f
4 . a * b + c * d
5 . a * b + c * d + e * f

11.3.2 表达式2

c + --c;

同上，操作符的优先级只能决定⾃减 – 的运算在 + 的运算的前⾯，但是我们并没有办法得知， + 操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

11.3.3 表达式3

int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf(“i = %d\n”, i);
return 0;
}

不同的编译器结果不同

11.3.4 表达式4

#include <stdio.h>
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun(); // 函数的调⽤先后顺序⽆法通过操作符的优先级确定。
printf( “%d\n”, answer);//输出多少？
return 0;
}

11.3.5 表达式5

//表达式5
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf(“%d\n”, ret);// ？
printf(“%d\n”, i);//4
return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都执⾏，看结果。

这段代码中的第⼀个 + 在执⾏的时候，第三个++是否执⾏，这个是不确定的，因为依靠操作符的优先级和结合性是⽆法决定第⼀个 + 和第三个前置 ++ 的先后顺序。

11.4 总结

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

完。。。。。