【C语言】室友看了这操作符，连王者都不准备打 |

✨写在前

• 💖 作者简介：大家好，我是泽奀。
• 🏆 嵌入式领域新星创作者 ➕ 作者周榜: 31 ➕ 总排名: 4427 👑 
• 📝 个人主页：泽奀的博客_CSDN博客
• 🎉 点赞 ➕ 评论 ➕ 收藏 == 养成习惯😜
• 📣 系列专栏：【C】系列_泽奀的博客-CSDN博客
• 💬 总结：希望你看完之后，能对你有所帮助，不足请指正！共同学习交流 🖊
• ✉️ 我们并非登上我们所选择的舞台，演出并非我们所选择的剧本 ♦  

目录

✨写在前面

🎓算术运算符 

🖊 加法运算符("+")

🖊 减法运算符("-")

🖊 乘法运算符("*") 

🖊 除法运算符("/")

🖊 取模运算符("%") 

🎓移位操作符 

🎓位操作符 

🖊 按位与运算符("&")

🖊 按位或运算符("|")

🖊 按位异或运算符("^") 

🎓赋值操作符 

🎓单目操作符 

🖊 ("!")逻辑反操作 

🖊 正值("+")和负值("-")

🖊 ("&")取地址运算符 

🖊 ("*")解引用运算符 

♦ (sizeof)操作数的类型长度

🖊 ("~") 按位取反

🎓自增自减运算符 

♦ (类型)强制类型转换   

🎓关系操作符

🎓逻辑操作符

🖊 ("&&") 称为逻辑与运算符

🖊 ("||") 称为逻辑或运算符

🖊 ("!") 称为逻辑非运算符

🎓条件操作符

♦逗号表达式 

🎓下标引用操作符 

🎓函数调用操作符

🎓结构成员访问操作符 

🪁 隐式类型转换

🎗 负数的整形

🎗 正数的整形

🎗 整形提升

📭操作数的优先级大小

🎓算术运算符 

🖊 加法运算符("+")

• 又称之为 双目运算符，即应该有两个变量参加运算，具有右结合性。描述：把两个操作数相加。

#include<stdio.h>
int main(void)
{
    printf("Arabic numerals = %d",1+1);
    return 0;
}

​

​

运行结果：Arabic numerals = 2

🖊 减法运算符("-")

• 又称之为 双目运算符，但"-"也可作负值运算符，此时为单目运算符。描述：从第一个操作数中减去第二个操作数。

#include<stdio.h>
int main(void)
{
    printf("Arabic numerals = %d",1-1);
    return 0;
}

​

​

运行结果：Arabic numerals = 0

🖊 乘法运算符("*") 

• 又称之为 双目运算符，具有左结合性。描述：把两个操作数相乘。

#include<stdio.h>
int main(void)
{
	printf("Arabic numerals = %d\n",2 * 2);
	return 0;
}

​

​

注意：数学上的是乘法(x)，而在我们编程当中是星号(*)。

运行结果：Arabic numerals = 4

🖊 除法运算符("/")

• 又称之为 双目运算符，具有左结合性。参与运算量均为整型时，结果也为整型，舍 去小数。如果运算量中有一个是实型，则结果为双精度实型。描述：分子除以分母。

注意：数学上的是除法(÷)，而在我们编程当中的是斜杠(/)。

下面用代码演示下：除法演示

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main(void)
{
	int a = 10;
	int a1 = 10;
	int b = 3;
	float b1 = 3.0;
	int c = a / b;
	float c1 = a / b1;
	printf("Take integer = %d\n", c);
	printf("Take decimal = %lf\n",c1);
 
	return 0;
}

​

上述👆代码编译运行结果：

🖊 取模运算符("%")

• 描述：分子除以分母，例如：8%3 = 2

注意：取模操作符是只能对整数进行取模的，而不能对小数进行取模运算。

取模运算符练习：算出 100~200 当中能被 2 除以的数字打印出来，并且用 count 计次打印出来的总数。代码示例显示如下：

#include <stdio.h>
int main(void)
{
	int i;
	int Count = 0;
	for (i = 100; i <= 200; i++)
	{
		if (i % 2 == 0)
		{
			printf("%d  ", i);
			Count++;
		}
	}
    printf("\nCount = %d\n", Count);
    return 0;
}

​

上述👆代码编译运行结果：

🎓移位操作符 

• 二进制左移运算符("<<")，将一个运算对象的各二进制位全部左移若干位 (左边的二进制位丢弃，右边补0)
• 注：高位丢弃，低位补0。
• 二进制右移运算符(">>")，将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。算数右移补的是最高位的数字，逻辑右移补的都是0。注意：我们通常都是采用的是算数右移的方式！
• 注：低位丢弃，高位补0『正数补0、负数补1』

​

<<(左移):最高位丢弃,最低位补0 
>>(右移)如下↓
1.无符号数(unsigned):最低位丢弃,最高位补0
2.有符号数(signed):最低位丢弃,最高位补符号位.(★)
注:取决于数据类型

​

​

例如 A = 2，A<<1，得到的数字是：4

• 00000000000000000000000000000010
• 00000000000000000000000000000100

例如 A = 2，A>>1，得到的数字是：1

• 00000000000000000000000000000010
• 00000000000000000000000000000001

注意：在按位移动的时候，我们要移动正常的位数，你可不能移动100位那就出大问题

• 如果这里不怎么理解的话可以看看这篇文章：原码、反码和补码_泽奀的博客-CSDN博客

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

•  例如：

​

 int num = 2;
num << -5; //错误
 

​

🎓位操作符 

🖊 按位与运算符("&")

• 双目运算符。其功能是参与运算的两数各对应的二进位相与，只有对应的两个二进位均为 1 时，结果位才为 1，否则为 0。参与运算的数以补码方式出现。

运算规则

0&0=0;   
0&1=0;    
1&0=0;     
1&1=1;

例如：9 & 5，代码如下所示：

#include <stdio.h>
int main(void)
{
	int a = 9;                //00001001 - 9
	int b = 5;                //00000101 - 5
	int c = a & b;            //00000001 - 1
	printf("number = %d\n", c);
    return 0;
}

•  运行结果：number = 1

🖊 按位或运算符("|")

• 双目运算符。其功能是参与运算的两数各对应的二进位相或。只要 对应的二个二进位有一个为 1 时，结果位就为 1。参与运算的两个数均以补码出现。

运算规则

0|0=0;   
0|1=1;   
1|0=1;    
1|1=1;

例如：9 & 5，代码如下所示：

#include <stdio.h>
int main(void)
{
	int a = 9;                //00001001 - 9
	int b = 5;                //00000101 - 5
	int c = a | b;            //00001100 - 12
	printf("number = %d\n", c);
    return 0;
}

• 运行结果： number = 1

🖊 按位异或运算符("^")

• 参与运算的两个值，如果两个相应位相同，则结果为0，否则为1。
• 相同为0，一个数字异或上了0就相当于本身的那个数字。

运算规则

0^0=0;   
0^1=1;   
1^0=1;  
1^1=0;

例如：将 a = 9 和 b = 5 的值进行交换，不能创建变量进行交换！代码如下所示：

#include <stdio.h>
int main(void)
{
	int a = 9;
	int b = 5;
	printf("交换之前:a = %d  b = %d\n", a, b);
	a = a ^ b; // 1001 ^ 0101 = 1100 (12)
	b = a ^ b; // 1100 ^ 0101 = 1001 (9)
	a = a ^ b; // 1100 ^ 1001 = 0101 (5) 
	printf("交换之后:a = %d  b = %d\n", a, b);
    return 0;
}

从上面代码我们可以知道，按位异或(^)，可以不用创建临时变量达到交换两个数字的值。 

• 运行结果：交换之前：a = 9    b = 5    换行    a = 5    b = 9
• 注：位操作符都必须是整数！ 

🎓赋值操作符 

• 赋值操作符是一个很棒的操作符,他可以让你得到一个你之前并不满意的值。也就是你可以给自己重新进行赋值。连续赋值的方法是：从右向左的(ง •_•)ง。当然如果连续赋值你觉得不怎么理解的话，也可以分开。例如：

#include <stdio.h>
int main(void)
{
	int a = 10;
	int b = 20;
	int c = 30;
	a = b = c + 2;
	printf("连续赋值:%d\n", a);
	b = c + 2;
	a = b;
	printf("分开赋值:%d\n", a);

    return 0;
}

上述代码 连续赋值 和 分开赋值 结果都是一样的，但是 步骤是不一样的！  连续赋值 它的语法虽然是支持的，但是并不支持用 连续赋值 的方法。能拆开的话更好点。

只要是符合语法上的逻辑都可以这样去进行使用！ 注意：①个("=") 为赋值，②个("==") 为等号判断！

🎓单目操作符 

🖊 ("!")逻辑反操作  描述：把 假 变成 真，把 真 变成 假。所以，！为 单目操作符，只有一个操作数的符。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main(void)
{
	printf("%d\n", !1);
	printf("%d\n", !0);
	printf("%d\n", !5);
	return 0;
}

运行结果🖊 0  1  0  在C语言当中只要不是0那么就为真，只有0和1两种结果。

🖊 正值("+")和负值("-") 作用：顾名思义，"+"为正数，"-"号为负数

int a = 10;
a = -a;    // a = -10
a = +a;    // a = 10

🖊 ("&")取地址运算符  描述：地址就是内存区中对每个字节的编号。地址就是用来通过内存区的编号找到变量，然后再把自己内存区的编号赋值给指针 以十六进制进行打印出来，%p ---- 表示十六进制的数据输出。 注意：取地址不光光只是取出地址，这一个小小的符号("&")实际上有③种作用

1. 一种是按位与：1 & 5。
2. 一种就是这里说的取地址。
3. 另一种声明引用，相当于定义变量别名。

🖊 ("*")解引用运算符  描述：解引用一个指针将返回该指针所指的对象，为解引用的结果赋值。也就是为指针所指的对象赋值 指针变量就是用来进行存放地址的

int a = 20;   //(1)
int *pa = &a; //(2)
*pa = 30;     //(3)

1. a在内存中要分配空间4个字节!
2. 取出a的地址赋值给指针变量pa， pa说明执行对象是int类型!
3. 进行解引用操作符 *pa 就是通过解引用(*pa)里边的地址来找到地址a的! 

♦ (sizeof)操作数的类型长度 描述：实际上是获取了数据在内存中所占用的存储空间，以字节为单位来计数

int a = 1;
printf("%d\n",sizeof(a));  //①
printf("%d\n",sizeof(int));//②
printf("%d\n",sizeof a);   //③

以上三种写法均是可以的。 注意：第③种写法是可以的，由此证明了 sizeof 是一个操作符，并不是函数。 

当然 sizeof 也是可以计算数组的大小的。例如：

char arr[10] = {0}; 

数组是 10 个元素，每个数组元素是char类型的，①个char类型是一个字节，那这里就是10个字节。单位是字节，当然里面也可以是数组的类型。  拓展：sizeof 括号中放的表达式是不参与运算当中的！

🖊 ("~") 按位取反

• 描述：对一个数的二进制 0 变成 1 以及 1 变成 0。注意：是对 补码 进行按位取反。
• 所谓的按位取反是包括符号位在内 在内存级别直接进行比特位翻转。

int a = -1;
//原码:100000000000000000000000000000001
//反码:111111111111111111111111111111110
//补码:111111111111111111111111111111111

int b = ~a;//b = 0

//进行取反(a) 赋值 b
//取反:000000000000000000000000000000000   

🎓自增自减运算符 

• 在 C 语言中还有两个特殊的运算符"++"和"--"。自增运算符和自减运算符对变量的操作分别是增加1 和 减少1。自增运算符和自减运算符可以防在变量的前面或者是后面，防止变量前面称之为前缀，放在后面称之为后缀。使用方法如下：

--operator;//自减前缀运算符
operator--;//自减后缀运算符
++operator;//自增前缀运算符
operator--;//自增后缀运算符

在上面的这些例子中，运算符的前面后面的位置并不重要，因为所得到的结果是一样的。自减就是-1，自增就是+1。 注意：在表达式内部，作为运算符的一部分，两者的用法可能有所不同。如果运算符放在变量的前面，那么变量在参加表达式运算之前完成自增或者自减运算；如果运算符放在变量后面，那么变量的自增或者自减运算符在变量参加了表达式运算之后完成。

1. 自增/自减 后缀运算符是：后置 ++/--，先使用，再++/--。
2. 自增/自减 前缀运算符是：前置 ++/--，先++/--，再使用。

#include <stdio.h>
int main(void)
{
	int a = 1;
	int b = a++;//自增后缀运算符
	int d = 1;
	int c = ++d;//自增前缀运算符
	printf("自增后缀运算符:%d\n",b);
	printf("自增前缀运算符:%d\n", c);
    return 0;
}

♦ (类型)强制类型转换   

• 描述：把变量从一种类型转换为另一种数据类型。

int a = 3.14;

 此时，编译器就会报warning，当我强制转换的话！

int a = (int)3.14;

编译器就不会产生warning，说明我们的程序并没有问题。

🎓关系操作符

关系运算符是用于了两个数值进行比较，返回一个真值或者假值。返回针织还是假值，取决于表达式当中所用的运算符。其中真值为二进制(1)，假值为二进制(0)，针织表示指定的关系成立，假值则表达式指定的关系不成立。

>(大于)        >=(大于等于)    <(小于)
<=(小于等于)   !=(不等于)     ==(等于)

这里的关系操作符都是比较容易理解的，但是也要注意几个点：

• 在编程的过程当中，"=="是等于，而“=”是赋值。
• "=="比较两个字符串相等是不能使用等号的，用字符串函数 strcmp

🎓逻辑操作符

• 注：非0即为真，0即为假。

🖊 ("&&") 称为逻辑与运算符 如果两个操作数都非零，则条件为真。表示并且的意思。如下代码所示：

当为真的时候，打印结果为：表达式结果为真

#include <stdio.h>
int main(void)
{
	int a = 1;
	int b = 1;
	if (a && b)
		printf("表达式结果为真\n");
	else
		printf("表达式结果为假\n");
	return 0;
}

 当为假的时候：打印结果为：表达式结果为假

#include <stdio.h>
int main(void)
{
	int a = 0;
	int b = 1;
	if (a && b)
		printf("表达式结果为真\n");
	else
		printf("表达式结果为假\n");
	return 0;
}

当 a、b 变量都为 0 的时候，那么也是：表达式结果为假 注→对于 && 来说，左边已经为 false(假) 就不再执行右边的操作了。

🖊 ("||") 称为逻辑或运算符 如果两个操作数中有任意一个非零，则条件为真。表示或者的意思。如下代码所示：

当为真的时候，打印结果为：表达式结果为真

#include <stdio.h>
int main(void)
{
	int a = 1;
	int b = 0;
	if (a || b)
		printf("表达式结果为真\n");
	else
		printf("表达式结果为假\n");
	return 0;
}

当为假的时候：打印结果为：表达式结果为假

#include <stdio.h>
int main(void)
{
	int a = 0;
	int b = 0;
	if (a || b)
		printf("表达式结果为真\n");
	else
		printf("表达式结果为假\n");
	return 0;
}

当 a、b 变量都为 1 的时候，那么就是： 表达式结果为真 注→对于 || 来说，左边是 true 真的话就不会在执行右边的操作了。

🖊 ("!") 称为逻辑非运算符 用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。举例说明：

#include <stdio.h>
int main(void)
{
	int a = 0;
	int b = 0;
	if (!(a || b))
		printf("表达式结果为真\n");
	else
		printf("表达式结果为假\n");
	return 0;
}

例如：上面的代码，原本应该打印的是：表达式结果为假，但是，最后却打印出来的是：表达式结果为真。这就是逻辑非运算符的作用，可以把原本为假的值变成真，反之真的值变成假。注意：操作符的优先级，逻辑非(!)的优先级在上面是最高的。

🎓条件操作符

exp1 ? exp2 : exp3 分别为 表达式1 ? 表达式2 ：表达式3

• 条件操作符也被称之为三目操作符，唯①一个具有三个数的操作符。如下例子：

if(a>b)
{
    max = a;
}
else
{
    max = b;
}

不过，C语言提供了一种更加简单的方法，叫做条件运算符，语法格式为： 表达式1 ? 表达式2 : 表达式3 条件运算符是C语言中唯一的一个三目运算符，其求值规则为：如果表达式1的值为真，则以表达式2 的值作为整个条件表达式的值，否则以表达式3的值作为整个条件表达式的值。条件表达式通常用于赋值语句之中。 上面的 if else 等价于：

max = (a>b) ? a : b;

该语句的语义是：如a>b为真，则把a赋予max，否则把b赋予max。 

♦逗号表达式 

格式:exp1,exp2,exp3,...expn

• 逗号表达式，就是用逗号隔开的多个表达式。逗号表达式，从左向右依次执行，整个表达式的结果是最后的表达式的结果。这是一个很特殊的表达式，如下所示：

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

    return 0;
}

从上面的例子运行出的结果为：3，结果有可能会受到前面代码的影响！ 下面来做一道练习题，主要考察的是自增自减以及逗号表达式

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

在上面代码当中需要注意：逗号表达式的规则，以及自增运算符的前置与后置区别。 

🎓下标引用操作符 

下标引用操作符就是访问数组下标的那个操作符，下标从都是从0开始的，依次类推下来 举例说明：

假设,拿出数组名第5个元素。
int arr[10] = {1,2,3,4,5,6,7,8,9,10};

printf("arr = %d\n",arr[4]);

如上所示：这样访问数组名当中下标当中4，就可以找到数组名第⑤个元素。这里面的方括号 就是下标引用操作符，通过下标来找到数组名的元素，是访问具体某一个元素。 

🎓函数调用操作符

()函数调用操作符，接收一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。函数的参数分为两种，第一种：实际参数，第二种：形式参数。 真实传递给函数的参数，叫做实际参数。实参的参数可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须要有确定的值，以便把这些值传递给到形参当中去。  形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元）调用一瞬间才会开辟内存空间，所以叫做形式参数。形式参数当函数调用完成之后就会自动销毁了。因此形式参数只是在函数当中有效！声明周期范围有限。 举例说明：例如用 Add()函数 实现整形 a，b 的加减👇

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int Add(int a, int b)
{
	return a + b;
}
int main(void)
{
	int a = 0;
	int b = 0;
	printf("请输入两个数字:");
	scanf("%d %d", &a, &b);
	int ret = Add(a, b);
	printf("sum = %d\n", ret);

	return 0;
}

•  上述代码可能运行结果：输入 5 5，结果：10

🎓结构成员访问操作符 

• . 结构体 . 成员名，访问的内容。
• -> 结构体指针 -> 成员名，指向对象的内容。

结构体和其他类型基础数据类型一样，例如 int 类型，char 类型 只不过结构体可以做成你想要的数据类型。以方便日后的使用。在实际项目中，结构体是大量存在的。研发人员常使用结构体来封装一些属性来组成新的类型。结构体在函数中的作用不是简便，其最主要的作用就是封装。封装的好处就是可以再次利用。让使用者不必关心这个是什么，只要根据定义使用就可以了。

结构体的基础知识：这些值称之为成员变量，结构的每个成员都可以是不同类型的变量。

• 结构体就不再多去描述了，要了解的话可以看看这篇文章。https://blog.csdn.net/weixin_52632755/article/details/119980420

https://blog.csdn.net/weixin_52632755/article/details/119980420

这篇文章是博主写的结构体文章，里面是讲述结构体知识的全面讲解🧊

🪁 隐式类型转换

C语言的整形算数运算符总是至少以缺省整形类型的精度来进行的。注意：int(整形) 为了获得这个精度，表达式中的字符和短整型操作符在使用之前，都必须转换为整形提升。

🎗 负数的整形

char a = -1;

变量 a 的二进制补码只有⑧个比特位，因为1字节 = 8比特位。补码 1111 1111 在上面说过表达式中的字符型(char)在使用之前都是需要进行整形提升的时候，高位补上符号位，即为1。所以提升后的结果是：补码 1111 1111 1111 1111 1111 1111 1111 1111

🎗 正数的整形

char b = 1;

变量 b 的二进制补码只有⑧个比特位，因为 1字节 = 8比特位。补码 0000 0001 因为 char 为有符号的 char，所以整形提升的时候，高位补充符号位，即为0。所以整形提升之后的结果是：注意，原、反、补(正数一样) 0000 0000 0000 0000 0000 0000 0000 0001

🎗 整形提升

#include<stdio.h>
int main(void)
{
	int c = 0xFF;
	char b = 0xF4;
	short a = 0xFE;

	if (a == 0xF1)
		printf("Yes\n");
	if (b == 0xF4)
		printf("Yes1\n");
	if (c == 0xFF)
		printf("Yes2\n");
	return 0;
}

编译器运行结果：Yes2 所以从上面的例子就可以得出 变量 b 和 变量 a，由于是 char 和 short 类型，所以发生了整形提升，使得值也得到了提升，才没有执行 if 判断里面的内容。

📭操作数的优先级大小

1. 运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
2. 例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
3. 下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

说明： 在表达式中常常会出现这样的情况，例如：要进行 a+b，再将结果与 c 进行相乘，一不小心将表达式写成是 a+b*c。因为 *(乘号) 的优先级高于 + 号，这样的话就会先去执行 乘法运算符 的计算，显然这不是我们期望的到的结果。这个时候那么应该是怎么办呢?可以使用括号"()"将 + 运算级别提高，使其先进行运算，就可以得到自己所预期的结果了。

• 注意：小括号"()"在运算符当中的优先级是最高的！

下面出一道关于操作符优先级的题目 

#include<stdio.h>
int main(void)
{
	int i = 10;
	int j = 20;
	int k = 3;
	k *= i + j;
	printf("k = %d\n", k);
	return 0;
}

看到这道题有些小伙伴可能都会认为 k = 50，其实一开始我也是这样，结果，运行的时候才发现越来 k = 90。当时的我还不明白这个是为什么，结果一看，原来是优先级的问题 注意：在这里 + 的优先级比 *= 的优先级高!当然上面的代码其实本身并不好，因为没有可读性。我们可以把代码改下:k *= (i+k);这样的代码可读性就提高了

码字不易，如果对你有帮助的话，还请支持下鸭💖