前言

C语言中操作符不多，但是有些相同的操作符都是在不同的表达式中，有不同的解释意思，在c语言中有着必不可缺的作用，它们能使一些算法变得简单，接下来就由我来为大家详细解说。

操作符分类

注意：以下操作符都必须是英文的半角符号。

算术操作符	+ 　 * 　 / 　 %
移位操作符	<< 左移操作符　>> 右移操作符
位操作符	＆ 按位与 　^ 按位异或 　｜ 按位或
赋值操作符	＝　＋＝　－＝　＊＝　／＝　＆＝　｜＝　　＾＝
单目操作符	! 逻辑反操作　- 负值　+ 正值　& 取地址　sizeof 操作数的类型长度（以字节为单位）　~ 对一数的二进制按位取反　– 前置、后置--　++前置　后置++
关系操作符	＞　＜　＜＝　＞＝　==　!=
逻辑操作符	＆ ＆ 逻辑与　｜｜逻辑或
条件操作符	exp1 ? exp2 : exp3
逗号表达式	exp1, exp2, exp3, …expN
下标引用	[ ] 下标引用操作符
函数调用	( )
结构成员	.　结构体.成员名　- >　结构体指针->成员名

• 算数操作符

   +  -	 *	/	%
// 加 减 乘 除 取余

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

#include<stdio.h>
int main()
{int a = 5;int b = 2;int c = 0;printf("a+b = %d\n", a + b);//相加printf("a-b = %d\n", a - b);//相减printf("a*b = %d\n", a * b);//相乘printf("a/b = %d\n", a / b);//求商printf("a%%b = %d\n", a % b);//取模return 0;
}

当除数为小数时，int类型只会截取整数部分。

• 移位操作符

·<< 左移操作符
·>> 右移操作符
左移操作符 移位规则： 左边抛弃、右边补0

右移操作符 移位规则：

首先右移运算分两种：

1. 逻辑移位 左边用0填充，右边丢弃

2. 算术移位 左边用原该值的符号位填充，右边丢弃

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

例如：

int num = 10;

num>>-1;//error

• 位操作符

& （按位与） 二进制补码 两真才真（1） 一假则假（0）
| （按位或） 二进制补码 一真则真（1） 两假才假（0）
^ (按位异或） 二进制补码 相异为真（1） 相同为假 (0）

练习一下：

#inciude<stdio.h>
int main()
{int num1 = 1;int num2 = 2;num1 & num2;num1 | num2;num1 ^ num2;return 0;
}

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

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

• 赋值操作符

"="
注意：这是赋值操作符，并不是等于。c语言中的等于是"=="。

复合赋值符 += -= *= /= %= >>= <<= &= |= ^= 符合赋值操作符与其他运算符一样的道理。这样写更加简洁

• 单目操作符

! 逻辑反操作

-      负值+      正值

&          取地址
*           间接访问操作符(解引用操作符)  

sizeof 操作数的类型长度（以字节为单位）

~ 对一个数的二进制按位取反

– 前置、后置–
++ 前置、后置++

//++和--运算符
//前置++和--
//前置++和--：
#inciude<stdio.h>
int main()
{int a = 10;int x = ++a;//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。 int y = --a; //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;return 0;
]

//后置++和-- 
#include<stdio.h>
int main()
{int a = 10;int x = a++;//先对a先使用，再增加，这样x的值是10；之后a变成11；int y = a--;//先对a先使用，再自减，这样y的值是11；之后a变成10；return 0;
}

(类型）强制类型转换
强制类型转换是通过类型转换运算来实现的。其一般形式为：（类型说明符）（表达式）其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。自动转换是在源类型和目标类型兼容以及目标类型广于源类型时发生一个类型到另一类的转换。

• 关系操作符

关系运算符的应用

• 关系运算符的运算结果只有 0 或 1。当条件成立时结果为 1，条件不成立结果为 0。
• 我们来看一段代码，如下：
• #include <stdio.h> int main() { printf("%d\n", 1 > 2); printf("%d\n", 1 < 2); return 0; }
  得到的输出结果为：

0
1

• 原因就是1 > 2在数学上是不成立的，所以结果为0；而1 < 2在数学上是不成立的，所以结果为1

• 逻辑操作符

1.&& 逻辑与 判断规则：两真则真，一假就假
2.|| 逻辑或 判断规则：一真则真，两假才假

详解：
位操作符中的 & 和 | 操作的是数的二进制补码 逻辑操作符中的 && 和 || 操作的是数本身 （数为0为假，数为非0为真）
使用逻辑操作符之后，若表达式整体判断为真，则值为1（1表示真，固定值） 若表达式整体判断为假，则值为0（0表示假，固定值）


总结:
逻辑与操作&& ： 左边判断为假后，右边的表达式不再执行，直接停止，返回值0（假）
逻辑或操作 || 左边判断为真后，右边的表达式不再执行，直接停止，返回值1（真）

• 条件操作符

exp1 ? exp2 : exp3

解释：表达式1进行判断，若结果为真，则 exp1 ? exp2 : exp3 整体的结果为 表达式 exp2 的结果
若结果为假，则exp1 ? exp2 : exp3 整体的结果为 表达式 exp3 的结果
exp是expression的缩写，中文意思为“表达”

举例：

#include<stdio.h>
int main()
{int a = 10;int b = 20;int max;//if (a > 5)//	b = 3;//else//	b = -3;//b = a > 5 ? 3 : -3;max = a > b ? a : b;printf("a = %d\nb = %d\nmax = %d\n", a, b, max);return 0;
}

• 逗号表达式

exp1, exp2, exp3, …….expN

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

#include<stdio.h>
int main()
{int a = 1;int b = 2;int c = (a > b, a = b + 10, a, b = a + 1);printf("%d\n", c);return 0;
}

讲解： 这里我们要输出c的值，那么c的值是什么呢？

int c = (a > b, a = b + 10, a, b = a + 1);
这里初始化c的时候应用了逗号表达式，逗号表达式从左向右依次执行，整个表达式结果为最后一个表达式的结果，我们按照这个原则去推导，a > b 执行但是没有结果 a = b + 10 相当于a = 2 + 10 = 12, a执行但不产生结果，b = a + 1 = 12 + 1 = 13，整个表达式的值也等于b 即c = 13。

对于这个结果我们可以运行程序验证一下。

• 下标引用

下标引用操作符 [ ]
操作数： 一个数组名 + 一个索引值

#include<stdio.h>
int main()
{int a[10] = { 0 };//1.定义一个数组//2.如果我们想要访问第5个数组元素，并给其赋值a[4] = 10;//3.用数组变量名+[]+下标索引数字//4.[ ] 对应的两个操作数一个是变量名a  另外一个就是下标/索引值 4printf("%d\n", a[4]);return 0;

• 函数调用

函数调用操作符()
接收一个或者多个操作数，第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include<stdio.h>
//2.这个地方的()不是函数调用操作符，是函数定义的语法规则
int get_max(int x, int y)
{return x > y ? x : y;
}
int main()
{int a = 10;int b = 20;//1.调用函数的时候使用的() 就是函数调用操作符int max = get_max(a, b);//3.这里的函数调用操作符()的操作数为 函数名get_max，函数参数a，函数参数b  总共三个操作数//4.对于函数调用操作符()而言，其操作数至少要有一个（函数名），可以有多个printf("max = %d\n", max);return 0;
}

• 结构成员

在C语言中，可以使用结构体（Struct）来存放一组不同类型的数据。
结构体的定义形式为：

struct 结构体名{
结构体所包含的变量或数组
};

结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每个这样的变量或数组都称为结构体的成员（Member）。
例如：

struct stu{char *name; //姓名int num; //学号int age; //年龄char group; //所在学习小组float score; //成绩
};

stu 为结构体名，它包含了 5 个成员，分别是 name、num、age、group、score。结构体成员的定义方式与变量和数组的定义方式相同，只是不能初始化。
注意：大括号后面的分号;不能少，这是一条完整的语句。
结构体也是一种数据类型，它由程序员自己定义，可以包含多个其他类型的数据。

像 int、float、char 等是由C语言本身提供的数据类型，不能再进行分拆，我们称之为基本数据类型；而结构体可以包含多个基本类型的数据，也可以包含其他的结构体，我们将它称为复杂数据类型或构造数据类型。

• 结构体变量
  既然结构体是一种数据类型，那么就可以用它来定义变量。
  eg:

struct stu stu1, stu2;
定义了两个变量 stu1 和 stu2，它们都是 stu 类型，都由 5 个成员组成。注意关键字struct不能少。

stu就像一个“模板”，定义出来的变量都具有相同的性质。也可以将结构体比作“图纸”，将结构体变量比作“零件”，根据同一张图纸生产出来的零件的特性都是一样的。

你也可以在定义结构体的同时定义结构体变量： 将变量放在结构体定义的最后即可。

struct stu{char *name; //姓名int num; //学号int age; //年龄char group; //所在学习小组float score; //成绩
} stu1, stu2;

如果只需要 stu1、stu2 两个变量，后面不需要再使用结构体名定义其他变量，那么在定义时也可以不给出结构体名，如下所示：

struct{ //没有写 stuchar *name; //姓名int num; //学号int age; //年龄char group; //所在学习小组float score; //成绩
} stu1, stu2;

这样做书写简单，但是因为没有结构体名，后面就没法用该结构体定义新的变量。

• 成员的获取和赋值

结构体和数组类似，也是一组数据的集合，整体使用没有太大的意义。数组使用下标[ ]获取单个元素，结构体使用点号.获取单个成员。获取结构体成员的一般格式为：
结构体变量名.成员名;
通过这种方式可以获取成员的值，也可以给成员赋值：

#include <stdio.h>
int main(){struct{char *name; //姓名int num; //学号int age; //年龄char group; //所在小组float score; //成绩} stu1;//给结构体成员赋值stu1.name = "Tom";stu1.num = 12;stu1.age = 18;stu1.group = 'A';stu1.score = 136.5;//读取结构体成员的值printf("%s的学号是%d，年龄是%d，在%c组，今年的成绩是%.1f！\n", stu1.name, stu1.num, stu1.age, stu1.group, stu1.score);return 0;
}

除了可以对成员进行逐一赋值，也可以在定义时整体赋值

struct{char *name; //姓名int num; //学号int age; //年龄char group; //所在小组float score; //成绩
} stu1, stu2 = { "Tom", 12, 18, 'A', 136.5 };

不过整体赋值仅限于定义结构体变量的时候，在使用过程中只能对成员逐一赋值，这和数组的赋值非常类似。

需要注意的是，结构体是一种自定义的数据类型，是创建变量的模板，不占用内存空间；结构体变量才包含了实实在在的数据，需要内存空间来存储。

总结

如何记忆两种结合性和15种优先级？
结合性有两种，一种是自左至右，另一种是自右至左，大部分运算符的结合性是自左至右，只有单目运算符、三目运算符的赋值运算符的结合性自右至左。
优先级有15种。
记忆方法：

记住一个最高的：构造类型的元素或成员以及小括号。
记住一个最低的：逗号运算符。
剩余的是一、二、三、赋值。
意思是单目、双目、三目和赋值运算符。