🎓算术运算符
🖊 加法运算符("+")
- 又称之为 双目运算符，即应该有两个变量参加运算，具有右结合性。描述：把两个操作数相加。
#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; }
🖊 乘法运算符("*")
- 又称之为 双目运算符，具有左结合性。描述：把两个操作数相乘。
1. #include<stdio.h> 2. int main(void) 3. { 4. printf("Arabic numerals = %d\n",2 * 2); 5. return 0; 6. }
注意：数学上的是乘法(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，负数左补1，右边丢弃。算数右移补的是最高位的数字，逻辑右移补的都是0。注意：我们通常都是采用的是算数右移的方式！
例如 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^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; }
上述代码 连续赋值 和 分开赋值 结果都是一样的，但是 步骤是不一样的！
连续赋值 它的语法虽然是支持的，但是并不支持用 连续赋值 的方法。能拆开的话更好点。
只要是符合语法上的逻辑都可以这样去进行使用！
注意：①个("=") 为赋值，②个("==") 为等号判断！
🎓单目操作符
🖊 ("!")逻辑反操作
描述：把 假 变成 真，把 真 变成 假。所以，！为 单目操作符，只有一个操作数的符。
int lis = 1; printf("逻辑为真 - %d\n",lis); printf("逻辑为假 - %d", !lis);
- 逻辑为真 = 1
- 逻辑为假 = 0
🖊 正值("+")和负值("-")
作用：顾名思义，"+"为正数，"-"号为负数
1. int a = 10; 2. a = -a; // a = -10 3. a = +a; // a = 10
🖊 ("&")取地址运算符
描述：地址就是内存区中对每个字节的编号。地址就是用来通过内存区的编号找到变量，然后再把自己内存区的编号赋值给指针
以十六进制进行打印出来，%p ---- 表示十六进制的数据输出。
注意：取地址不光光只是取出地址，这一个小小的符号("&")实际上有③种作用
一种是按位与：1 & 5。
一种就是这里说的取地址。
另一种声明引用，相当于定义变量别名。
🖊 ("*")解引用运算符
描述：解引用一个指针将返回该指针所指的对象，为解引用的结果赋值。也就是为指针所指的对象赋值
指针变量就是用来进行存放地址的
int a = 20; //(1) int *pa = &a; //(2) *pa = 30; //(3)
a在内存中要分配空间4个字节!
取出a的地址赋值给指针变量pa， pa说明执行对象是int类型!
进行解引用操作符 *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。
注意：在表达式内部，作为运算符的一部分，两者的用法可能有所不同。如果运算符放在变量的前面，那么变量在参加表达式运算之前完成自增或者自减运算；如果运算符放在变量后面，那么变量的自增或者自减运算符在变量参加了表达式运算之后完成。
自增/自减 后缀运算符是：后置 ++/--，先使用，再++/--。
自增/自减 前缀运算符是：前置 ++/--，先++/--，再使用。
#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)，针织表示指定的关系成立，假值则表达式指定的关系不成立。
下面出一道关于操作符优先级的题目
#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);这样的代码可读性就提高了
