简介
c语言之所以对于很多人来说很难，就是因为它的操作符太多，很多人不能熟练掌握导致学起来有困难，本文将c语言中的各种操作符进行汇总以便于大家学习。
正文
一、分类
操作符可以分为以下类别：
算数操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符、逗号表达式、下标引用、函数调用和结构成员。
二、介绍
1、首先，我们从算术操作符开始，算数运算符用于各类数值运算，那么算术操作符有哪些呢？
+ - * / %
这些大家都不陌生，有一些细节需要提一提：
（1）、除了%操作符之外，其他的几个操作数可以作用于整数和浮点数。
（2）、对于/操作符，如果两个操作数都为整数，执行整数除法。而只要有浮点数就执行浮点数除法。
（3）、%操作符的两个操作数必须为整数。返回的是整除之后的余数。
2、移位操作符
移位操作符执行后，对变量无影响。
<< 左移操作符
>> 右移操作符
左移操作符的移位规则：
左边抛弃、右边补0
如图为移位方式
右移操作符的移位规则：
右移操作分为两种：
（1）算术右移：左边用原该值的符号位填充，右边丢弃
（2）逻辑右移：左边用0填充，右边丢弃
扫描二维码关注公众号，回复： 3935473 查看本文章
注意：对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：
int num = 10;
num>>-1;//error 3、位操作符
位操作符是针对于二进制位来运算的，有以下操作符：
& 按位与
| 按位或
^ 按位异或
注意：它们的操作数必须是整数。
按位与：二进制位中做运算的两个位都为1则为1，有0则为0；
按位或：二进制位中做运算的两个位有1则为1，都为0则为0；
按位异或：二进制位中做运算的两个位相异为1，相同为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;
} 4、赋值操作符
赋值操作符 = 就是用来给你的定义的变量重新赋值。
int a = 0;
a = 100;//重新赋值为100还有复合赋值符
+= a = a+1可以写成a+=1;下面的以此类推
-=
*=
/=
%=
>>=
<<=
&=
|=
^=
5、单目操作符
单目操作符是指运算所需变量为一个的运算符，下面列举出来单目运算符：
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个二进制数按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符（解引用操作符）
(类型) 强制类型转换
接下来对单目操作符进行一 一分析：
（1）！逻辑反操作
对逻辑进行取反，如果为真，运算后变为假，反之亦然；
（2）-和+没什么可讲的，表示正负，上过小学的都会；
（3）& 取地址操作符
从内存中取地址（注：不能从寄存器register中取址。）；
（4）sizeof 操作数的类型长度
用法：sizeof(类型说明符，数组名或表达式)或sizeof(变量名)。
可以求变量(类型)所占空间的大小（注意：sizeof不是函数，它是一个操作符）；
#include<stdio.h>
int main()
{
int a = 10;
int *p = NULL;
p = &a;
printf("%d\n",sizeof(a));//输出4
printf("%d\n",sizeof(int));//输出4
printf("%d\n",sizeof a);//输出4
//printf("%d\n",sizeof int);//语法错误
return 0;
}sizeof和数组
#include<stdio.h>
void test1(int arr[])
{
printf("%d\n",sizeof(arr));//40 计算的是数组大小
}
void test2(char ch[])
{
printf("%d\n",sizeof(ch));//10 同上
}
int main()
{
int arr[10] = {0};
char ch[10] = {0};
printf("%d\n",sizeof(arr));//4 计算的是指针
printf("%d\n",sizeof(ch));//4 同上
test1(arr);
test2(ch);
return 0;
}（5）~ 对一个二进制数按位取反
对一个二进制数每一位0变1，1变0；
（6）-- 这个操作符分为前置--和后置--
前置--表示先进行自减，再引用
后置--表示先引用，然后自减
++操作符同理；
代码如下
#include<stdio.h>
int main()
{
int a = 10;
int x = ++a;//先对a进行自增，然后使用a的值赋给x，x为11
int y = --a;//先对a进行自减，然后使用a的值赋给y，y为10
int w = a--;//先使用a的值，再给a自减，这样w的值为10，之后a变为9
int z = a++;//先使用a的值，再给a自增，这样z的值为9，之后变为10
return 0;
} 6、关系操作符
关系操作符就是用作比较的时候用的
> 大于
< 小于
>= 大于等于
<= 小于等于
！= 不等于
== 等于
唯一要注意的就是不要混淆了==和=的区别。
7、逻辑操作符
表达式1&&表达式2---------------->全真则为真
表达式1 | | 表达式2----------------->有真则为真
&& 逻辑与
|| 逻辑或
注意：要区分逻辑或和按位或，逻辑与和按位与
1&2 ==0 对二进制计算
1&&2 ==1 看逻辑
1|2 == 3
1||2 == 1
一道笔试题：
#include<stdio.h>
int main()
{
int i = 0,a = 0,b = 2,c = 3,d = 4;
//i = a++ && ++b && d++; //执行完a=1,b=2,c=3,d=4;&&前为假后面就不用算了
i = a++ || ++b || d++; //执行完a=1,b=3,c=3,d=4;||前为真后面就不用算了
printf("a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
return 0;
}8、条件操作符（三目操作符）
表达式1？表达式2：表达式3
表达式1若为真则执行表达式2，为假则执行表达式3.
9、逗号表达式
表达式1，表达式2，表达式3, …表达式n
逗号表达式，就是用逗号隔开的多个表达式。逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
例如：
int a = 1;
int b = 2;
int c = (a>b,a=b+10,a,b=a+1);//从左向右依次执行，最终算出c等于13 10、下标引用、函数调用和结构成员
（1）[ ]下标引用操作符
操作数：一个数组名和一个索引值
int arr[10];//创建数组
arr[9] = 10;//使用下标引用操作符
//[]的两个操作数是arr和9（2）（）函数调用操作符，接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
比如在主函数调用之前定义的函数
#include<stdio.h>
void test1()
{
printf("abc\n");
}
void test2(const char *str)
{
printf("%s\n",str);
}
int main()
{
test1();//使用（）作为函数调用操作符。
test2("def");//使用（）作为函数调用操作符。
return 0;
}（3）访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
#include<stdio.h>
struct Stu//定义一个结构体
{
char name[10];
int age;
char sex[5];
};
void set_age1(struct Stu stu)//stu为结构体变量
{
stu.age = 18;
}
void set_age2(struct Stu *pStu)
{
pStu->age = 18;//结构成员访问
}
int main()
{
struct Stu stu;//创建结构体变量
struct Stu *pStu = &stu;//结构成员访问
stu.age = 20;//结构成员访问
set_age1(stu);
pStu->age = 20;//结构成员访问
set_age2(pStu);
return 0;
}给结构体成员赋字符串用strcpy函数，赋数值的话就直接赋。
struct Stu s = {0};
strcpy (S.name,"张三");
//也可以这样
struct stu
{
char name[10];
int age;
char sex[5];
};
int main()
{
struct stu s = {"李四"，20，"男"};//注意顺序不能乱
struct stu *ps = &s;
printf("%s\n",(*ps).name);//输出名字
//ps->name//或者这样输出
} 运算符的优先级
附上关于运算符优先级以及结合性的表如下：
##总结
操作符的属性：
1.操作符的优先级
2.操作符的结合性
3.是否控制求值顺序。
两个相邻的操作符先执行哪个，取决于他们的优先级。如果两者优先级相同，取决于他们的结合性。