C语言之操作符

1.操作符的分类

• 算数操作符：+、-、*、/、%
• 移位操作符：<< >>
• 位操作符：& | ^ `
• 赋值操作符：= 、+= 、 -+、 *=、 /=、 %=、 <<=、 >>=、 |=、 ^=
• 单目操作符：！、 ++、 --、 &、 *、 +、 -、 ~、 sizeof、(类型)
• 关系操作符：>、 >=、 <、 <=、 ==、 ！=
• 逻辑操作符：&&、||
• 条件操作符：？ ：
• 逗号操作符：，
• 下标操作符：[]
• 函数调用：（）
• 结构成员访问：. 、 ->

2.二进制和进制转换

2进制、8进制、10进制、16进制是数值的不同表示形式
例如：数值15的各种进制的表示形式

15的2进制：1111
15的8进制：17
15的10进制：15
15的16进制：F

十进制

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

二进制
2进制中满2进1
2进制的数字每一位都是0~1的数字组成

那么1101就是二进制的数字了。

2进制转10进制

其实10进制的123表示的值实施一百二十三，为什么是这个值呢？其实10进制的每一位是权重的，10进制的数字从右向左是个位、十位、百位……，分别每一位的权重是10⁰ ,10¹ ,10² ……

2进制和10进制是类似的，只不过2进制的每一位权重，从右向左是：2⁰,2¹,2²……

10进制转2进制数字

2进制转8进制

8进制的数字每一位是0~7的数字，各自写成2进制，最多有三个2进制位就足够了，比如7的二进制十111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每个2进制位会换算一个8进制位，剩余不够3个2进制位的直接转换。

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

2进制转16进制

16进制的数字每一位是0~~9 ,_a~f的数字，各自写成2进制，最多有4个2进制位就足够了
比如：f的二进制十1111.所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算一个16进制位，剩余不够4个二进制位的直接转换。

3.原码、反码、补码

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

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

符号位都是用0表示“正”，用1表示“负”。

正整数的原、反、补码都相同。

负整数的三种表示方法各不相同。

原码：直接将数值按照正负数的形式翻译成二进制得到的就是原码。

反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。

补码：反码+1就得到补码。

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

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

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

4.移位操作符

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

注：移位操作符的操作数只能是整数。

左移操作符

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

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

右移操作符

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

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

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

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

位操作符有：

1. & 按位与
   当两个相应的位进行与运算，则遵循有0得0，全1得1的规则

1010
0110

将上面两个进行按位与运算，得0010

2. | 按位或

   当两个相应的位进行或运算，则遵循有1得1，全0得0的原则

1010
0110

将上面两个进行按位或运算，得1110

3. ^ 按位异或

   当两个相应的位进行按位异或运算，则遵循相同得0，不同得1的原则

1010
0110

将上面两个进行按位异或运算，得1100

4. ~ 按位取反

   当对一个数的位进行反运算，则遵循遇0得1，遇1得0的原则

1010

将上面这个数进行按位取反运算，得0101

注：他们的操作数必须是整数

int main()
{
	int num1 = -3;
	int num2 = 5;
	printf("%d\n", num1 & num2);
	printf("%d\n", num1 | num2);
	printf("%d\n", num1 ^ num2);
	printf("%d\n", ~0);
	return 0;
}

练习1. 不创建临时变量，实现两个数的交换

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

练习2.求一个整数在内存中的二进制中1的个数

int main()
{
	int num = -1;
	int count = 0;//计数
	while (num)
	{
		count++;
		num = num&(num-1);
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}

练习3.二进制位置0或者置1

编写代码将13二进制序列的第五位修改为1，然后再改回0

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

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

6.单目操作符

!、++、–、&、*、+、-、~、sizeof、（类型）

单目操作符的特点是只有一个操作数。

7.逗号操作符

exp1,exp2,exp3,……expN

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, a, b = a + 1);
	printf("%d", c);//c=13
	return 0;
}

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

[ ]下标引用操作数

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

int arr[ 10 ] ; //创建数组
arr[ 9 ] = 10 ; //使用下标引用操作符
[ ]的两个操作数的arr和9

函数调用操作数

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

void test1()
{
	printf("good job\n");
}
void test2(const char *str)
{
	printf("%s\n", str);
}


int main()
{
	test1();	//这里的（）就是作为函数调用的操作符
	test2("hello msy"); //这里的（）就是函数调用的操作符
	return 0;
}

9.结构成员访问操作符

结构体

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

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

结构的声明

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

描述一个学生：

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

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

//代码1：变量的定义
struct Point
{
	int x; 
	int y;
}p1;	//声明类型的同时定义变量p1
struct Point p2;	//定义结构体变量p2

//代码2：初始化
struct Stu
{
	char name[15];//姓名
	int age;//年龄
};
struct Stu s1 = { "zhangsan",18 };//初始化
struct Stu s2 = { .age = 20,.name = "lisi" };//指定顺序初始化

//代码3
struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

结构成员访问操作符

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

struct Point
{
	int x;
	int y;
}p={1,2};

int main()
{
	printf("x:%d y:%d\n", p.x, p.y);
	return 0;
}

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

结构体成员的间接访问

有时候我们得到的不是一个结构体变量，而是得到了一个指向结构体的指针。

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 <string.h>

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

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

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

优先级

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

3 + 4 *5

上述例子中，巴大师3 + 4 * 5 里面既有加法运算符（+），又有乘法运算符（）。由于乘法的优先级高于加法，所以会先计算45，而不是先计算3+4.

结合性

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

• 圆括号（）
• 自增运算符（++），自减运算符（–）
• 单目运算符（+和-）
• 乘法（*），除法（/）
• 加法（+），减法（-）
• 关系运算符（<、>等）
• 赋值运算符（=）
• 由于圆括号的优先级最高，可以使用它改变其他运算符的优先级。

11.表达式求值

整型提升

C语言中整型算术运算总是至少以缺省整型类型的精度来进行的

未来获得这个精度，表达式中的字符和短整型操作数造使用之前被转换为普通整型，这种转换称为整型提升。

实例
char 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 9

算术转换

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

long double
double
float
unsigned long int
long int
unsigned int
int

如果某个操作数的类型在上面的这个列表中排名靠后，那么首先要转换为另一个操作数的类型后执行运算。

问题包大师解析

表达式1

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

表达式1在计算的时候，由于*比+来的优先级高，只能保证，的计算时比+早，但是优先级并不能决定第三个比第一个+早。

表达式2

//表达式2
c + --c

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

总结
即使有了操作符的优先级和结合性，我们写出的表达式依然可能不能通过操作符的属性确定唯一的计算路径，那么这个表达式就是存在潜在的风险的。