初始C语言（6）- 操作符

于 2023-10-09 14:08:43 发布
阅读量99 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： C 文章标签： c语言 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wangjie0517/article/details/133691108
本文围绕C语言操作符展开，介绍了操作符的定义，将其分为算术、移位、位、赋值等多种类型，并详细阐述各类型操作符特点。同时讲解了表达式求值，包括隐式类型转换、算术转换和操作符属性，指出表达式若不能确定唯一计算路径则存在问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、什么是操作符

操作符也称运算符，是一种表示对数据进行某种运算处理的符号。 C语言的运算符按完成的运算操作性质 ：

可以分为算术运算符、关系运算符、逻辑运算符、赋值运算符和其他运算符。

2、操作符分类

算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员

2.1算术操作符

+    -   *   /   % 

 + - * / 都是我们熟知的，较为陌生的是 %（取余）

例如：

10 / 3 = 3    （我们得到的是商）

10 % 3 = 1 （我们得到的是余数）

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

2.2移位操作符

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

移位操作符又分为：左移操作符   右移操作符

<< 左移操作符
>> 右移操作符
   
注：移位操作符的操作数只能是整数。

既然要移位我们就要知道 原码、反码、补码。

正整数的原反补码相同。

负整数

原码：把一个数按照正负直接翻译成二进制

反码：原码取反

补码：反码+1

2.2.1左移操作符

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

 通俗讲就是需要左移几位就移几位，右边空缺的地方补0

2.2.2右移操作符 

移位规则：
首先右移运算分两种：
1. 逻辑移位
左边用0填充，右边丢弃
2. 算术移位
左边用原该值的符号位填充，右边丢弃

采用逻辑移位还是算术移位取决于编译器 

举个例子：

举个例子： 

警告⚠ ：
对于移位运算符，不要移动负数位，这个是标准未定义的。
int num = 10;
num>>-1;//error

 2.3位操作符

位操作符有：
&  //按位与 （同1为1，有0为0）
|   //按位或  （有1为1，同0为0）
^  //按位异或（相同为0，相异为1）
注：他们的操作数必须是整数。

 举个栗子：

看这个图就很明白啦 

我们来看一道实际应用的题

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

#include <stdio.h>
int main()
{
     int a = 10;
     int b = 20;
     a = a^b;
     b = a^b;
     a = a^b;
     printf("a = %d b = %d\n", a, b);
     return 0;
}

 也可以利用两数的和，差来计算，但是如果两个数很大相加超过了int范围就会出现问题；利用^不会出现溢出。

2.4赋值操作符

赋值操作符简单的说就是给你的变量赋值，或者修改变量的值。

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。
赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值
这样的代码感觉怎么样？
那同样的语义，你看看：
x = y+1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=
这些运算符都可以写成复合的效果。
比如：
int x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。
int y = 5;
y = y-10;
y -= 10;

2.5单目操作符 

2.5.1单目操作符分类

!              逻辑反操作
-              负值
+             正值
&             取地址
sizeof      操作数的类型长度（以字节为单位）
~              对一个数的二进制按位取反
--              前置、后置--
++            前置、后置++
*               间接访问操作符(解引用操作符)
(类型)       强制类型转换

光说不练假把式

int main()
{
	int a = -10;
	int* p = NULL;
	printf("%d\n", !2);
	printf("%d\n", !0);
	a = -a;
	p = &a;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof a);//这样写行不行？
	printf("%d\n", sizeof int);//这样写行不行？
	return 0;
}
sizeof求变量（类型）所占空间的大小

 2.5.2sizeof 和 数组 

void test1(int arr[])
{
	printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));//(4)
}

int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//(1)
	printf("%d\n", sizeof(ch));//(3)
	test1(arr);
	test2(ch);
	return 0;
}

结果如下图： 

#include <stdio.h>
int main()
{
   int a = 10;
   int x = ++a;
//先对a进行自增，然后对使用
a，也就是表达式的值是a自增之后的值。x为11。
   int y = --a;
   //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
   return 0;
}
//后置++和--
#include <stdio.h>
int main()
{
   int a = 10;
   int x = a++;
   //先对a先使用，再增加，这样x的值是10；之后a变成11；
   int y = a--;
   //先对a先使用，再自减，这样y的值是11；之后a变成10；
   return 0;
}

前置 

 后置

 2.6关系操作符

>
>=
<
<=
!=   用于测试“不相等”
==      用于测试“相等”

关系操作符大多数用于条件的判断 

if(x <= y)

        return 1;

else if(x == y)

        return 2;

else if(x >=y)

        return 3;

类似于这样的代码

注意：
在编程的过程中== 和=不小心写错，导致的错误。

2.7逻辑操作符

&&       逻辑与
||          逻辑或
区分逻辑与和按位与
区分逻辑或和按位或
1&2----->0
1&&2---->1 （左边大于0为真，右边大于0为真，结果为1）
1|2----->3
1||2---->1（左边大于0为真，或者右边大于0为真，结果为1）

 我们看一道题就能清楚的知道为什么了

#include <stdio.h>
int main()
{
   int i = 0,a=0,b=2,c =3,d=4;
   i = a++ && ++b && d++;
   //i = a++||++b||d++; // a = 1 , b = 3 , c = 3, d = 4 
   printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
   return 0;
}

 由此我们可以得出结论

&& 操作符左边为假，右边不再计算

||    操作符左边为真，右边不再计算

2.8条件操作符 

exp1 ? exp2 : exp3

举个栗子： 

if (a > 5)
       b = 3;
else
       b = -3;
转换成条件表达式，是什么样？
b=( (a > 5) ? 3 : -3)

2.9逗号表达式 和 下标引用、函数调用和结构成员

exp1, exp2, exp3，..... ,expn
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
1. [ ] 下标引用操作符
操作数：一个数组名 + 一个索引值
int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
[ ]的两个操作数是arr和9。
2. ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
#include <stdio.h>
void test1()
{
        printf("hehe\n");
}
void test2(const char *str)
{
        printf("%s\n", str);
}
int main()
{
        test1();            //实用（）作为函数调用操作符。
        est2("hello bit.");//实用（）作为函数调用操作符。
        return 0;
}
3. 访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
#include <stdio.h>
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;
}

 3、表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

3.1隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长
度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令
中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转
换为int或unsigned int，然后才能送入CPU去执行运算。
//实例1
char a,b,c;
...
a = b + c;

 b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整体提升呢？

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

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0

举个例子： 

int main()
{
     char c = 1;
     printf("%u\n", sizeof(c));
     printf("%u\n", sizeof(+c));
     printf("%u\n", sizeof(-c));
     return 0;
}
c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节.
表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节.

 3.2算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
注意：但是算术转换要合理，不然会有潜在问题。
float f = 3.14;
int num = f;//隐式转换，会有精度丢失

 3.3操作符的属性

复杂表达式的求值有三个影响的因素。
1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级
操作符       描述用法示例结果类型结合性 是否控制求值顺序
（）聚组（表达式）与表达
式同		N/A否
（）函数调用rexp（rexp，...,rexp）rexpL-R否
[ ]下标引用rexp[rexp]lexpL-R否
.访问结构成员lexp.member_namelexpL-R否
->访问结构指针成员rexp->member_namelexpL-R否
++后缀自增lexp ++rexpL-R否
--后缀自减lexp --rexpL-R否
!逻辑反! rexprexpR-L否
~按位取反~ rexprexpR-L否
+单目，表示正值+ rexprexpR-L否
-单目，表示负值- rexprexpR-L否
++前缀自增++ lexprexpR-L否
--前缀自减-- lexprexpR-L否
*间接访问* rexplexpR-L否
&取地址& lexprexpR-L否
sizeof取其长度，以字节
表示		sizeof rexp sizeof(类
型)		rexpR-L否
(类
型）		类型转换(类型) rexprexpR-L否
*乘法rexp * rexprexpL-R否
/除法rexp / rexprexpL-R否
%整数取余rexp % rexprexpL-R否
+加法rexp + rexprexpL-R否
-减法rexp - rexprexpL-R否
<<左移位rexp << rexprexpL-R否
>>右移位rexp >> rexprexpL-R否
>大于rexp > rexprexpL-R否
>=大于等于rexp >= rexprexpL-R否
<小于rexp < rexprexpL-R否
<=小于等于rexp <= rexprexpL-R否
==等于rexp == rexprexpL-R否
!=不等于rexp != rexprexpL-R否
&位与rexp & rexprexpL-R否
^位异或rexp ^ rexprexpL-R否
|位或rexp | rexprexpL-R否
&&逻辑与rexp && rexprexpL-R是
||逻辑或rexp || rexprexpL-R是
? :条件操作符rexp ? rexp : rexprexpN/A是
=赋值lexp = rexprexpR-L否
+=以...加lexp += rexprexpR-L否
-=以...减lexp -= rexprexpR-L否
*=以...乘lexp *= rexprexpR-L否
/=以...除lexp /= rexprexpR-L否
%=以...取模lexp %= rexprexpR-L否
<<=以...左移lexp <<= rexprexpR-L否
>>=以...右移lexp >>= rexprexpR-L否
&=以...与lexp &= rexprexpR-L否
^=以...异或lexp ^= rexprexpR-L否
|=以...或lexp |= rexprexpR-L否
，逗号rexp，rexprexpL-R是

下面我们来看一些问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释：代码在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不
能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是
a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f
或者：
a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f

//代码-非法表达式
int main()
{
        int i = 10;
        i = i-- - --i * ( i = -3 ) * i++ + ++i;
        printf("i = %d\n", i);
        return 0;
}

 表达式在不同编译器中测试结果：非法表达式程序的结果

值编译器
—128Tandy 6000 Xenix 3.2
—95Think C 5.02(Macintosh)
—86IBM PowerPC AIX 3.2.5
—85Sun Sparc cc(K&C编译器)
—63gcc，HP_UX 9.0，Power C 2.0.0
4Sun Sparc acc(K&C编译器)
21Turbo C/C++ 4.5
22FreeBSD 2.1 R
30Dec Alpha OSF1 2.0
36Dec VAX/VMS
42Microsoft C 5.1

总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

以上就是对操作符的理解，如果有不对不妥之处欢迎大家留言交流！！！
 

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王朵拉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值