操作符详解

KrisZhang10

已于 2023-11-16 13:24:13 修改

阅读量132

点赞数 2

分类专栏： C语言初阶文章标签： c语言

于 2023-11-05 17:44:30 首次发布

本文链接：https://blog.csdn.net/m0_61630449/article/details/134222687

版权

C语言初阶专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、操作符分类

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

⚠️注意

整数在内存中存的是补码

算术操作符

+ - * / %

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

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

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

移位操作符

左移操作符

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

正数左移

注意⚠️⚠️

负数进行左移时，也是补码移动，移动后结果显示原码

原码得补码两种方法都可以

右移操作符

移位规则：

首先右移运算分两种：

1. 逻辑移位

左边用0填充，右边丢弃

2. 算术移位

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

如果是正数两个都一样

所以编译器绝大部分情况下用的是算术右移

警告⚠：

对于移位运算符，不要移动负数位。（没有意义）

例如：

int num = 10;

num>>-1;//error

位操作符(只适用于整数)

位操作符有：

& //按位与 0&0=0 0&1=0 1&1=1（有0为0，同1为1）（重合）

| //按位或 0|0=0 0|1=1 1|1=1（有1为1，同0为0）(只要有1就是1)

^ //按位异或（同为0，异为1）

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

按位与：结果为3

（这里注意正数的原反补一样）

按位或：结果为-5

异或：结果为-8

一道经典题：

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

a ^ a = 0;

0 ^ a = a;

3 ^ 3 ^ 5 = 5;

3 ^ 5 ^ 3 = 5;//异或符合交换律

#include <stdio.h>

int main()

{

        int a = 10;

        int b = 20;

        a = a^b;

        b = a^b;//b = (a^b)^b;

        a = a^b;//a = a^(a^b);

        printf("a = %d b = %d\n", a, b);

        return 0;

}

赋值操作符

= 这个我想不用讲了

复合赋值符

>>=

<<=

单目操作符

这里等于-1

值得注意⚠️的是

（）强制类型转换还是一种临时的状态。

在int b结束的下一条语句开始就还是float类型

还有就是写成int b = int(a)这样写是错误的

关系操作符

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。

警告：

在编程的过程中== 和=不小心写错，导致的错误。如死循环之类的。

逻辑操作符

&& 逻辑与

|| 逻辑或

区分逻辑与和按位与

区分逻辑或和按位或

1&2----->0

1&&2---->1

1|2----->3

1||2---->1

一道笔试题⚠️⚠️

答案是1 2 3 4 ，因为短路运算。有一个假后面就不会计算了

答案是2 2 3 4，也是因为短路运算。有一个为真后面就不重要了。

条件操作符

exp1 ? exp2 : exp3

int a = 0,int b = 0;

scanf("%d",&a);

if (a > 5)

{
b = 3;

}

else

{
b = -3;

}

以上代码使用条件操作符：

(a>5)?(b=3):(b=-3);

也可以写成：

b = ((a > 5) ? 3 : -3);

逗号表达式

exp1, exp2, exp3, …expN

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

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

a = get_val();

count_val(a);

while (a > 0)

{

//业务处理

        a = get_val();

        count_val(a);

}

如果使用逗号表达式，改写：

while (a = get_val(), count_val(a), a>0)

{

          //业务处理

}

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

[ ]下标引用操作符

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

int arr[10]; //创建数组

arr[9] = 10; //实用下标引用操作符。

[ ]的两个操作数是arr和9。

( )函数调用操作符

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

访问一个结构的成员

. 结构体.成员名

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

. 的应用

#include <stdio.h>

struct S
{
    int num;
    char c;
};//上面就是一个结构体类型的数据

int main()
{
    struct S man/*用这个结构体类型创建一个变量，创建了一个man对象*/={100,'b'};//结构体初始化的使用{}
    //打印结构中的成员数据
    printf("%d\n",man.num);//打印出100
    printf("%c\n",man.c);//打印出c
    //.操作符      结构体变量.结构体成员名
    return 0;
}

-> 的应用

#include <stdio.h>

struct S
{
    int num;
    char c;
};//上面就是一个结构体类型的数据
void print(struct S* man)
{
    printf("%d\n",(*man).num);
    printf("%c\n",(*man).c);
    //->结构成员访问操作符
    //结构体指针->结构体成员
    printf("%d\n",man->num);
    printf("%c\n",man->c);
}
int main()
{
    struct S man/*用这个结构体类型创建一个变量，创建了一个man对象*/={100,'b'};//结构体初始化的使用{}
    print(&man);
    return 0;
}

表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令

中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

//负数的整形提升

char c1 = -1;

变量c1的二进制位(补码)中只有8个比特位： 1111111

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为1 提升之后的结果是： 11111111111111111111111111111111

//正数的整形提升

char c2 = 1;

变量c2的二进制位(补码)中只有8个比特位： 00000001

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为0 提升之后的结果是： 00000000000000000000000000000001

//无符号整形提升，高位补0

#include <stdio.h>

int main()
{
    char a = 3;
    //00000000 00000000 00000000 00000011 //3的二进制表示形式也可以认为是补码，正数正反补相同
    //要存进char就要发生截断变成   00000011
    char b = 127;
    //00000000 00000000 00000000 01111111
    //01111111
    char c = a + b;
    //计算的时候a和b都是char类型就会发生整形提升，再执行加法运算
    //加法运算完成之后，结果将被截断，然后再存储于a中。
    // 00000011
    //01111111
    //整形提升：
    //00000000 00000000 00000000 00000011
    //00000000 00000000 00000000 01111111
    //00000000 00000000 00000000 10000010
    //截断后c放  10000010
    printf("%d\n",c);
    //是%d又进行整形提升
    //char有符号所以高位补1：
    //11111111 11111111 11111111 10000010（补码）
    //11111111 11111111 11111111 10000001（反码）
    //10000000 00000000 00000000 01111110（原码）
    //-126
    return 0;
}

算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double

double

float

unsigned long int

long int

unsigned int

int

不到整形的，先整形提升，已经达到整形的向上进行转换的

比如int和float做除法，就会成float型

（如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。）

警告：

但是算术转换要合理，要不然会有一些潜在的问题。

float f = 3.14;

int num = f;//隐式转换，会有精度丢失

操作符的属性（操作符也叫运算符）

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

操作符优先级

或者：

操作符	描述	用法示例	结果类型	结合性	是否控制求值顺序
（）	聚组	（表达式）	与表达式同	N/A（表示没有结合性）	否
（）	函数调用	rexp（rexp，...,rexp）	rexp	L-R（从左向右）	否
[]	下标引用	rexp[rexp]	lexp	L-R	否
.	访问结构成员	lexp.member_name	lexp	L-R	否
->	访问结构指针成员	rexp->member_name	lexp	L-R	否
++	后缀自增	lexp ++	rexp	L-R	否
--	后缀自减	lexp --	rexp	L-R	否
!	逻辑反	! rexp	rexp	R-L	否
~	按位取反	~ rexp	rexp	R-L	否
+	单目，表示正值	+ rexp	!"#$	R-L	否
-	单目，表示负值	- rexp	rexp	R-L	否
++	前缀自增	++ lexp	rexp	R-L	否
--	前缀自减	-- lexp	rexp	R-L	否
*	间接访问	* rexp	lexp	R-L	否
&	取地址	& lexp	rexp	R-L	否
sizeof	取其长度，以字节表示	sizeof rexp sizeof(类型)	rexp	R-L	否
(类型）	类型转换	(类型) rexp	rexp	R-L	否
*	乘法	rexp * rexp	rexp	L-R	否
/	除法	rexp / rexp	rexp	L-R	否
%	整数取余	rexp % rexp	rexp	L-R	否
+	加法	rexp + rexp	rexp	L-R	否
-	减法	rexp - rexp	rexp	L-R	否
<<	左移位	rexp << rexp	rexp	L-R	否
>>	右移位	rexp >> rexp	rexp	L-R	否
>	大于	rexp > rexp	rexp	L-R	否
>=	大于等于	rexp >= rexp	rexp	L-R	否
<	小于	rexp < rexp	rexp	L-R	否
<=	小于等于	rexp <= rexp	rexp	L-R	否

操作符	描述	用法示例	结果类型	结合性	是否控制求值顺序
==	等于	rexp == rexp	rexp	L-R	否
!=	不等于	rexp != rexp	rexp	L-R	否
&	位与	rexp & rexp	rexp	L-R	否
^	位异或	rexp ^ rexp	rexp	L-R	否
\|	位或	rexp \| rexp	rexp	L-R	否
&&	逻辑与	rexp && rexp	rexp	L-R	是
\|\|	逻辑或	rexp \|\| rexp	rexp	L-R	是
?:	条件操作符	rexp ? rexp : rexp	rexp	N/A	是
=	赋值	lexp = rexp	rexp	R-L	否
+=	以...加	lexp += rexp	rexp	R-L	否
-=	以...减	lexp -= rexp	rexp	R-L	否
*=	以...乘	lexp *= rexp	rexp	R-L	否
/=	以...除	lexp /= rexp	rexp	R-L	否
%=	以...取模	lexp %= rexp	rexp	R-L	否
<<=	以...左移	lexp <<= rexp	rexp	R-L	否
>>=	以...右移	lexp >>= rexp	rexp	R-L	否
&=	以...与	lexp &= rexp	rexp	R-L	否
^=	以...异或	lexp ^= rexp	rexp	R-L	否
\|=	以...或	lexp \|= rexp	rexp	R-L	否
，	逗号	rexp，rexp	rexp	L-R	是