C语言一篇文章给你讲清所有的操作符

前言

Hello，大家好，我是小陈，记得刚学操作符的时候很简单，到后面学了其余的操作符，觉得总是记不住，今天你看了我的文章，我保证你记得住。

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

1.算术操作符 : + - * / %

1.1 加法和减法

• 和 - 都是有两个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双目操作符。

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

1.2 乘法

#include <stdio.h>
int main()
{
	int num = 5;
	printf("%d\n", num * num);

	return 0;
}

1.3 除法和取余

除法的结果是商，模运算也即是取余，结果为余数
在除法，两端的操作数是整数，执行的是整数除法，得到的结果也是整数，如果除法的结果有余数则只保留整数部分，不保留小数部分

#include <stdio.h>
int main()
{
 float x = 6 / 4;
 int y = 6 / 4;
 printf("%f\n", x); // 输出 1.000000
 printf("%d\n", y); // 输出 1
 return 0;
}

如果希望得到浮点数的结果，也就是小数，两个数必须至少有一个浮点数，这时C语言就会进行浮点数除法

#include <stdio.h>
int main()
{
 float x = 6.0 / 4; // 或者写成 6 / 4.0
 printf("%f\n", x); // 输出 1.500000
 return 0;
}

易错例子

#include <stdio.h>
int main()
{
 int score = 5;
 score = (score / 20) * 100;
 return 0;
}

上面我们说了，两个操作符都是整数则进行整数除法，得到的结果为整数，所以商0余数为5，结果为0

#include <stdio.h>
int main()
{
 int score = 5;
 score = (score / 20.0) * 100;
 return 0;
}

这样结果就为25了。

1.4 取余模%

运算符 % 表⽰求模运算，即返回两个整数相除的余值。这个运算符只能⽤于整数，不能⽤于浮点数。

#include <stdio.h>
int main()
{
 int x = 6 % 4; // 2 余数为2
 return 0;
}

注意：在负数求模当中，第一个数字的正负性决定了这个运算结果的正负，即最左边的操作数。

#include <stdio.h>
int main()
{
 printf("%d\n", 11 % -5); // 1
 printf("%d\n",-11 % -5); // -1
 printf("%d\n",-11 % 5); // -1
 return 0;
}

2.移位操作符 : << >>

在介绍移位操作符时，我们先来讲一下二进制和进制转换

2.1二进制和进制转换

2进制、8进 制、10进制、16进制是数值的不同表⽰形式⽽已。
数值15的各种进制的表⽰形式：

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

重点介绍⼀下⼆进制： ⾸先我们还是得从10进制讲起，其实10进制是我们⽣活中经常使⽤的，我们已经形成了很多尝试：
• 10进制中满10进1
• 10进制的数字每⼀位都是0~9的数字组成 其实⼆进制也是⼀样的
• 2进制中满2进1
• 2进制的数字每⼀位都是0~1的数字组成 那么 1101 就是⼆进制的数字了。

2.2 2进制转10进制

其实10进制的每⼀位是权重的，10进 制的数字从右向左是个位、⼗位、百位…，分别每⼀位的权重是 10 , 10 , 10 …

2进制1101

其实在2进制转换为10进制的时候我们可以记住4个数字，即 8 4 2 1 ，这样可以方便我们计算

2.2.1 10进制转2进制数字

每一位进行除2操作，然后求余数，从下往上排列。

2.3 2进制转8进制和16进制

2.3.1 2进制转8进制

8进制的数字每⼀位是0_7的，07的数字，各⾃写成2进制，最多有3个2进制位就⾜够了，⽐如7的⼆ 进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算⼀ 个8进制位，剩余不够3个2进制位的直接换算。 如：2进制的01101011，换成8进制：0153，0开头的数字，会被当做8进制。

2.3.2 2进制转16进制

3. 原码、反码、补码

整数的2进制表⽰⽅法有三种，即原码、反码和补码
有符号整数的三种表⽰⽅法均有符号位和数值位两部分，2进制序列中，最⾼位的1位是被当做符号 位，剩余的都是数值位。
符号位都是⽤0表⽰“正”，⽤1表⽰“负”。

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

对于在计算机里的int(整型)来说，数据存放在内存中存放的是补码

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

4.移位操作符

左移操作符 <<
右移操作符 >>
左移操作符开口面向右，右移操作符开口向左
注：移位操作符的操作数只能是整数，且移动的是二进制的补码。

4.1 左移操作符

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

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

记住左移操作符的核心规则就可以。

4.2 右移操作符

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

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

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

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

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

3.位操作符 : &、|、^、 ~

位操作符：也是用二进制中的补码进行计算

& //按位与 规则：两个操作数对应二进制位同样为1 结果位 才为1，否则为0；全一出一，有0出0。 1为真，0为假
| //按位或 规则：两个操作数对应二进制位同样为0结果位 才为0，否则为1；全0出0，有1出1。
^ //按位异或 规则：两个操作数对应二进制位相同则结果位 为0，不同则为1; 相同为0，不同为1。
~ //按位取反 规则：一个二进制操作数，对应位为0，结果位为1；对应位为1，结果位为0； （作用是将每位二进制取反）

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

#include <stdio.h>
int main()
{
 int num1 = -3;
 int num2 = 5;
 printf("%d\n", num1 & num2);//5
 printf("%d\n", num1 | num2);//-3
 printf("%d\n", num1 ^ num2);//-8
 printf("%d\n", ~0);//-1
 return 0;
}

实现两个数交换

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

#include <stdio.h>
int main()
{
 int a = 10;
 int b = 20;
 a = a^b;
 b = a^b; //b = a^b^b = a
 a = a^b; // a= a^b^a =b
 printf("a = %d b = %d\n", a, b);
 return 0;
}

按位异或操作符
0 ^ 0 = 0 , a^a=0
0 ^ 1 = 1, a^0=a
1 ^ 0 = 1 ,
1 ^ 1 = 0 ,
按位异或的3个特点：
1.） 0 ^ 0 = 0 , 0 ^ 1 = 1, 0异或任何数=任何数。
2.）1 ^ 0 = 1 , 1 ^ 1 = 0 , 1异或任何数=任何数取反。
3.）任何数异或自己 = 把自己置0。

4.赋值操作符：=和复合赋值

在变量创建的时候给一个初始值叫初始化，在变量创建好后，再给一个值，这叫赋值

int a = 100;//初始化
a = 200;//赋值，这⾥使⽤的就是赋值操作符

赋值操作符 = 是⼀个随时可以给变量赋值的操作符。
注意：赋值操作符是把右边的常量值赋给左边的变量，两个不是意义上的相等，而是简单赋值了。

4.1 连续赋值

int a = 3;
int b = 5;
int c = 0;
c = b = a+3;//连续赋值，从右向左依次赋值的。

4.2 复合赋值符

 += -=
*= /= %=
>>= <<=
&= |= ^=

对⼀个数进⾏⾃增、⾃减的操作

int a = 10;
a = a+3;
a = a-2;

简便写法

int a = 10;
a += 3;
a -= 2;

*= /= %=
= <<=
&= |= ^=
这三行赋值操作符就不过多陈述了，它们本质上就是为了让一个1个数字进行运算时的简写

5.单目操作符 ： ！、 ++、–、+、- &、* 、sizeof、(类型)

前⾯介绍的操作符都是双⽬操作符，有2个操作数的。C语⾔中还有⼀些操作符只有⼀个操作数，被称 为单⽬操作符。 ++、–、+(正)、-(负) 就是单⽬操作符的。

5.1 ++和–

++是⼀种⾃增的操作符，⼜分为前置++和后置++，–是⼀种⾃减的操作符，也分为前置–和后置–.

5.1.1 前置++

int a = 10;
int b = ++a;//++的操作数是a，是放在a的前⾯的，就是前置++
printf("a=%d b=%d\n",a , b);

计算⼝诀：先+1，后使⽤；
a原来是10，先+1，后a变成了11，再使⽤就是赋值给b，b得到的也是11，所以计算技术后，a和b都 是11，相当于这样的代码：

int a = 10;
a = a+1;
b = a;
printf("a=%d b=%d\n",a , b);

5.1.2 后置++

int a = 10;
int b = a++;//++的操作数是a，是放在a的后⾯的，就是后置++
printf("a=%d b=%d\n",a , b);

计算⼝诀：先使⽤，后+1
a原来是10，先使⽤，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以直接结束后a是 11，b是10，相当于这样的代码：

int a = 10;
int b = a;
a = a+1;
printf("a=%d b=%d\n",a , b);

5.1.3 前置–

计算⼝诀：先-1，后使⽤

int a = 10;
int b = --a;//--的操作数是a，是放在a的前⾯的，就是前置--
printf("a=%d b=%d\n",a , b);//输出的结果是：9 9

5.1.4 后置–

同理后置–类似于后置++，只是把加⼀换成了减⼀
计算⼝诀：先使⽤，后-1

int a = 10;
int b = a--;//--的操作数是a，是放在a的后⾯的，就是后置--
printf("a=%d b=%d\n",a , b);//输出的结果是：9 10

5.2 + 和 -

这⾥的+是正号，-是负号，都是单⽬操作符。 运算符 + 对正负值没有影响，是⼀个完全可以省略的运算符，但是写了也不会报错。

 int a = +10; 等价于 int a = 10;

运算符 - ⽤来改变⼀个值的正负号，负数的前⾯加上 - 就会得到正数，正数的前⾯加上 - 会得到负 数

int a = 10;
int b = -a;
int c = -10;
printf("b=%d c=%d\n", b, c);//这⾥的b和c都是-10
int a = -10;
int b = -a;
printf("b=%d\n", b); //这⾥的b是10

5.3 sizeof

铁铁们，可以看这个文章。
C语言sizeof与strlen的区别

5.4 & *

5.4.1 取地址操作符（&）

#include <stdio.h>
int main()
{
 int a = 10;
 return 0;
}

:::tips
0x006FFD70
0x006FFD71
0x006FFD72
0x006FFD73
:::
如果我们想获得a的地址，就需要取地址操作符了。

#include <stdio.h>
int main()
{
 int a = 10;
 &a;//取出a的地址
 printf("%p\n", &a);//006FFD70
 return 0;
}

&a取出的是a所占4个字节中地址较⼩的字节的地 址。

5.4.2 解引⽤操作符（*）

我们将地址保存起来，未来是要使⽤的，那怎么使⽤呢？ 在现实⽣活中，我们使⽤地址要找到⼀个房间，在房间⾥可以拿去或者存放物品。 C语⾔中其实也是⼀样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针） 指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。

#include <stdio.h>
int main()
{
 int a = 100;
 int* pa = &a;
 *pa = 0;
 return 0;
}

上⾯代码中第7⾏就使⽤了解引⽤操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间， pa其实就是a变量了；所以pa = 0，这个操作符是把a改成了0.

6.关系操作符：> 、>= 、< 、<= 、 == 、 !=

6.1 反逻辑操作符 !=

#include <stdio.h>
int main()
{
int a = 10;
int b= 20;
a!=b;//这里的意思是a不等于b
 return 0;
}

6.2 > 、>= 、< 、<= 、 ==

#include <stdio.h>
int main()
{
int a = 10;
int b= 20;
int c  = 10;
a<b;
a=c;
//这里的操作符和数学一样，唯一值得注意的是 == 让两个数进行对比，看它们是否相等，而不是赋值，这一点要和=分清楚。
 return 0;
}

7.逻辑操作符： && 、||

7.1 逻辑与 &&

"&&"运算符两边的式子只有都是真，整个逻辑表达式的值才是真（即为1），否则整个逻辑表达式的值就是假（即为0）。

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = a && b;
	printf("%d\n",c);//1 全真则真，一假则假。
	return 0;
}

全真则真，一假则假。
值得注意的是，如果左边的操作数为假了，那么右边的操作数就不会计算了，这是一个重点。

7.2 逻辑或 ||

“||”运算符两边的式子只要一个式子为真，整个逻辑表达式的值就是真（即为1），否则整个逻辑表达式的值就是假（即为0）。

#include <stdio.h>
//一真一假
int main()
{
	int a = 0;
	int b = 5;
	int c = a || b;
	printf("%d\n",c);//1
	return 0;
}

#include <stdio.h>
//两个同时为假
int main()
{
	int a = 0;
	int b = 0;
	int c = a || b;
	printf("%d\n",c);//0
	return 0;
}

全假则假，一真为真。
值得注意的是，如果左边的操作数为真了，那么右边的操作数就不会计算了，这是一个重点。

8.条件操作符： ? :

1. 形式
   exp1 ? exp2:exp3
   如果表达式1为真，那么就计算表达式2，表达式2的结果为整个式子的 结果；
   如果表达式1为假，那么就计算表达式3，表达式3的结果为整个式子的结果。

这个操作符可以用在比较大小里，我们来实现一下。

#include <stdio.h>
*/ if (a > 5)
	b = 3;
else 
	b = -3; 
*/
  
  b = (a > 5 ? 3 : -3);

9. 逗号表达式

exp1, exp2, exp3, …expN

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

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

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//这里要注意的是a到底是多少？a=12，因为a被赋值为12了
c是多少？
//代码2
if (a =b + 1, c=a / 2, d > 0)
//代码3
a = get_val();
count_val(a);
while (a > 0)
{
 //业务处理
 a = get_val();
 count_val(a);
}
如果使⽤逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
 //业务处理
}

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

10.1 [ ] 下标引⽤操作符

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

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

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

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

11.1优先级

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

3 + 4 * 5;

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

11.2结合性

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

 5 * 6 / 2;

C语言运算符的优先级和结合性

12.结构体成员访问操作符

12.1结构体

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

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

12.1.1.结构的声明

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

描述⼀个学⽣：

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

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

//代码1：变量的定义
struct Point
{
 int x;
 int y;
}p1; //声明类型的同时定义变量p1
struct 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"};//指定顺序初始化
//代码3
struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

12.2.1结构成员访问操作符

点操作符（.）

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

结构体变量.成员名

12.2.2.结构体成员的间接访问

#include <stdio.h>
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;
}

结构体指针->成员名

13.完结

以上就是操作符所有的知识啦，如有遗漏，请指出，肝有点疼，先下线了。。。