【C语言】操作符----详解

 博客主页:江池俊的博客

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

 其他专栏：数据结构探索

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

 社区：C/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  11111111   11111111  1111 0101

补码： 11111111  11111111   11111111  1111 0110

左移操作符 <<

移位规则：

左边抛弃、右边补0

如图所示：

右移操作符 >>

 移位规则：

首先右移运算分两种：

1. 逻辑移位:

    左边用0填充，右边丢弃

2. 算术移位:

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

如图所示：

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

例如： 

int num=10
num>>-1;//error
num<<-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;//结果为1
int 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;          // 声明一个整型变量x
x = 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 等于 -5
int y = +10;  // y 等于 10

地址运算符 &

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

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

sizeof运算符 

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

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

 位取反运算符 ~

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

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

 递减运算符 -- 

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

递增运算符 ++

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

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

 间接寻址运算符 *

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

int num = 42;
int* ptr = #  // 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 ? exp2 : exp3

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

例：

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

逗号表达式

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

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//结果为13

//代码2
if (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;
}

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