博客主页:江池俊的博客

收录专栏：C语言——探索高效编程的基石

其他专栏：数据结构探索

代码仓库：江池俊的代码仓库

如果觉得博主的文章还不错的话，请点赞收藏 三连支持一下博主

目录

算术操作符

移位操作符

左移操作符 <<

右移操作符 >>

位操作符

按位与&

按位或|

按位异或^

赋值操作符

单目操作符

逻辑反操作!

（负值）-（正值）+

地址运算符 &

sizeof运算符

位取反运算符 ~

递减运算符 —

递增运算符 ++

间接寻址运算符*

强制类型转换 （类型）

关系操作符

逻辑操作符

条件操作符

逗号表达式

下标引用、函数调用和结构成员

下标引用操作符[ ]

函数调用操作符 （）

访问一个结构的成员 . or ->

操作符分类：

1.算术操作符

2.移位操作符

3.位操作符

4.赋值操作符

5.单目操作符

6.关系操作符

7.逻辑操作符

8.条件操作符

9.逗号表达式

10.下标引用、函数调用和结构成员

算术操作符

+- * / %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

移位操作符

<< 左移操作符

>> 右移操作符

注：移位操作符的操作数只能是整数。

移位操作符移动的其实是二进制的位

⁉️那么一个数字在计算机中的二进制序列是什么样的呢？

对于一个整数是4个字节，然而一个字节是8个bit位，那么一个整数就是32个bit位，而其中二进制的一个0或者一个1只占用一个bit位，所以一个整数写成二进制序列的时候，就是32个bit位。

◾️对于有符号整数来说，最高位的一位是符号位：

▪️ 符号位是1表示负数

▪️ 符号位是0表示正数

◾️对于无符号整数来说，没有符号位，所有位都是有效位。

现在我们知道了它们的二进制序列，

⁉️那么它们在计算机中又是怎么进行计算的呢？

原码、反码、补码

整数的二进制表示形式有三种：原码、反码、补码

原码：按照数值的正负，直接写出的二进制序列

反码：原码的符号位不变，其他位按位取反（即0变1,1变0）

补码：反码的二进制+1就得到了补码

对于正数来说，原码、反码、补码相同，无需计算

对于负数来说，原码、反码、补码不相同，是需要计算的

整数在内存中存储的都是补码的二进制序列

整数在计算的时候也使用的补码！

例如：

原码：00000000 00000000 00000000 00001010

反码：00000000 00000000 00000000 00001010

补码：00000000 00000000 00000000 00001010

-10：

原码：10000000 00000000 00000000 00001010

反码： 11111111 1111111111111111 1111 0101

补码： 11111111 1111111111111111 1111 0110

左移操作符 <<

移位规则：

左边抛弃、右边补0

如图所示：

右移操作符 >>

移位规则：

首先右移运算分两种：

1. 逻辑移位:

左边用0填充，右边丢弃

2. 算术移位:

左边用原该值的符号位填充，右边丢弃

如图所示：

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

例如：

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

位操作符

& 按位与

|按位或

^ 按位异或

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

按位与&

对两个操作数的每个对应位执行按位与操作，只有两位都为1时，结果为1，否则为0。

int a = 3;int b = -5;int c = a & b;//按（2进制）位与//c的结果为3

按位与&过程：

00000000000000000000000000000011 — a的补码
10000000000000000000000000000101 — b的原码
11111111111111111111111111111010— b的反码

11111111111111111111111111111011— b的补码

& 00000000000000000000000000000011 — a的补码
———————————————————————
00000000000000000000000000000011 — c的补码
00000000000000000000000000000011 — c的原码 == 3

一个数&1可得该数二进制最低位是0还是1

int a = 3;int b = -4;int c = a&1;//结果为1int d = b&1;//结果为0

过程：

1、a&1
00000000000000000000000000000011 — a的补码
& 00000000000000000000000000000001 — 1的补码
————————————————————–
00000000000000000000000000000001 — c==a&1的补码（原码）–>1

2、b&1

10000000000000000000000000000100— b的原码

11111111111111111111111111111111100— b的补码

& 00000000000000000000000000000001— 1的补码

—————————————————————

00000000000000000000000000000000— d=b&1的补码（原码）–>0

按位或|

对两个操作数的每个对应位执行按位或操作，只要对应的两位中有一个为1时，结果为1，否则为0。

按位异或^

对两个操作数的每个对应位执行按位异或操作，当两位不相同时，结果为1，相同时为0。

int a = 3;int b = -5;int c = a ^ b;//结果为-8

异或^过程：

10000000000000000000000000000101 — b的原码

11111111111111111111111111111010— b的反码

11111111111111111111111111111011— b的补码

^00000000000000000000000000000011 — a的补码

——————————————————————-

11111111111111111111111111111000— c==a^b的补码

1000000000000000000000001000— c的原码 –> -8

异或^的两个特点

1. a ^ a = 0

2. 0 ^ a = a

赋值操作符

赋值符号 =

复合赋值符：+=-=*=/=%=>>=<<=&=|=^=

赋值符号举例：将右边表达式的值赋给左边的变量

int x;// 声明一个整型变量xx = 10; // 使用赋值操作符将10赋值给x

复合赋值符举例：

int x = 5;x += 3; // 等同于 x = x + 3;x *= 2; // 等同于 x = x * 2;

单目操作符

单目运算符（Unary operators）是一种只操作一个操作数（即单个值或变量）的运算符。

! 逻辑反操作

– 负值

+ 正值

& 取地址

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

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

— 前置、后置–

++前置、后置++

* 间接访问操作符(解引用操作符)

(类型)强制类型转换

逻辑反操作!

逻辑非运算符 (!)：用于将布尔值取反。

bool isTrue = true;bool isFalse = !isTrue;// isFalse 等于 false

（负值）–（正值）+

负号运算符 (-)：将操作数的值取反。

正号运算符 (+)：将操作数的值保持不变（一般用于强调正数的正号，实际上不进行任何操作）。

int x = -5; // x 等于 -5int y = +10;// y 等于 10

地址运算符 &

地址运算符 (&)：用于获取变量的内存地址。

int num = 42;int* ptr = &num;// ptr 指向变量 num 的内存地址

sizeof运算符

sizeof运算符：用于获取数据类型或表达式的字节大小。

int sizeOfInt = sizeof(int);// 获取整型 int 的字节大小

位取反运算符 ~

位取反运算符 (~)：对操作数的每个位进行取反操作。

int a = 5; // 二进制表示为 000000000000000000000000000000101int b = ~a;// 取反后为 111111111111111111111111111111010 //即十进制 -6（取决于具体的位表示方式）

递减运算符 —

int x = 5;int y = --x;// 先将 x 的值减少为 4，然后将 x 的值赋给 y，所以 x 和 y 都等于 4int z = x--;// 先将 x 的值赋给 z（z = 4），然后将 x 的值减少为 3

递增运算符 ++

递增运算符 (++)：将操作数的值增加1。递增运算符也有前缀和后缀形式。

int a = 5;int b = ++a;// 先将 a 的值增加为 6，然后将 a 的值赋给 b，所以 a 和 b 都等于 6int c = a++;// 先将 a 的值赋给 c（c = 6），然后将 a 的值增加为 7

间接寻址运算符*

间接寻址运算符 (*)：用于获取指针指向的值。

int num = 42;int* ptr = &num;// ptr 指向变量 num 的内存地址int value = *ptr; // value 等于 ptr 指向的值（即 42）

强制类型转换 （类型）

强制类型转换：将操作数转换为指定的类型。

float num = 3.14;int intValue = (int)num;// 将浮点数 num 转换为整数 intValue，结果为 3

关系操作符

  1. 等于（==）：检查两个操作数是否相等。
  2. 不等于（!=）：检查两个操作数是否不相等。
  3. 大于（>）：检查左操作数是否大于右操作数。
  4. 小于（<）：检查左操作数是否小于右操作数。
  5. 大于等于（>=）：检查左操作数是否大于或等于右操作数。
  6. 小于等于（<=）：检查左操作数是否小于或等于右操作数。

关系运算符用于比较两个值之间的关系，并返回布尔值（true或false）。这些运算符经常在条件语句中使用，用于控制程序的执行流程。关系运算符可以帮助我们根据条件的真假执行不同的代码块，使程序具备更强的逻辑性和灵活性。在使用关系运算符时，需要注意操作数的数据类型和语义，以避免出现意外结果或错误。

警告： 在编程的过程中要注意== 和=的区别，不要写错，不然很容易导致程序错误，=是用做赋值操作，而==才是用来判断是否相等的。

逻辑操作符

&& 逻辑与

|| 逻辑或

区分逻辑与和按位与

区分逻辑或和按位或

1&2== 0 //按位与（二进制）1&&2 == 1 //逻辑与，只要有一个为假便为假1|2== 3 //按位或（二进制）1||2 == 1 //逻辑或，只要有一个为真便为真

逻辑与和或的特点：短路

1.逻辑或

#include int main(){int i = 0, a = 0, b = 2, c = 3, d = 4;i = a++ || ++b || d++;//----|| -- 左边操作数如果为真，右边无需计算printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);printf("i=%d\n", i);return 0;}

运行结果：

2.逻辑与

#include int main(){ int i = 0, a = 0, b = 2, c = 3, d = 4;i = a++ && ++b && d++;//------&& -- 左边操作数如果为假，右边无需计算printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);printf("i=%d\n", i);return 0;}

运行结果：

条件操作符

exp1 ” />exp1 ? exp2 : exp3中，exp1是一个条件表达式，用于判断条件是否为真。如果exp1为真，那么整个条件运算符的结果为exp2，否则为exp3。

例：

int num = 10;string result = (num % 2 == 0) ? "偶数" : "奇数";//如果 num 是偶数，则条件 (num % 2 == 0) 为真，整个条件运算符的结果为字符串 “偶数”；//如果 num 是奇数，则条件为假，结果为字符串 “奇数”。

逗号表达式

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

//代码1int a = 1;int b = 2;int c = (a>b, a=b+10, a, b=a+1);//结果为13//代码2if (a =b + 1, c=a / 2, d > 0)//if的判断条件为 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) {//业务处理a = get_val();count_val(a);}

下标引用、函数调用和结构成员

下标引用操作符[ ]

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

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

函数调用操作符 （）

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include  void test1() { printf("hehe\n"); } void test2(const char *str) { printf("%s\n", str); } int main() { test1();//使用（）作为函数调用操作符。 test2("hello world.");//使用（）作为函数调用操作符。 return 0; }

访问一个结构的成员 . or ->

. 结构体 . 成员名

->结构体指针 -> 成员名

#include struct Stu{ char name[10]; int age; char sex[5]; double score;}；void set_age1(struct 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;}

今天的分享就到这里，如果觉得博主的文章还不错的话，请三连支持一下博主哦