【C语言】操作符详解

猪猪侠to30

已于 2023-05-08 17:07:55 修改

阅读量170

点赞数 2

文章标签： c语言算法开发语言

于 2023-03-27 13:09:22 首次发布

本文链接：https://blog.csdn.net/L14777/article/details/129791395

版权

文章目录

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

本文重点

各种操作符的介绍。
表达式求值

我们在深入了解操作符之前，先了解一下操作符是什么，有哪些。

操作符是什么：
操作符也称运算符，是一种表示对数据进行某种运算处理的符号。

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

在了解大概后，我们需要知道，整数的二进制有3种表达形式

原码：把一个数直接按照正负直接翻译成二进制（最高一位是符号位）
反码：原码的符合位不变，其他位按位取反。
补码：反码+1。

值得注意的是：
1.在内存存的是补码的形式，但展示在我们面前的是原码的形式，只是存储为补码形式。
2.正整数的3码同一，负整数的3码需要计算。
3.2进制转化16进制的时候每4个二进制换算一个16进制

11222

算术操作符

+
-
*
/
%

算术操作符都是大家耳熟能详的东西，这里只提几个注意点
1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

移位操作符

左移操作符 <<
右移操作符>>

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

左移操作符

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

int main()
{
	int a = -3;
	//10000000000000000000000000000011  //原码
	//11111111111111111111111111111100	//反码
	//11111111111111111111111111111101	//补码
	int b = a << 1;
	//11111111111111111111111111111010	//左移
	//10000000000000000000000000000101	//取反   注意我们是先取反再+1！，而且不能改变符合位
	//10000000000000000000000000000110	//+1
	printf("%d", b);
	return 0;
}

如上图代码并不会改变a的值，你想改变a的值就这样写 a=a<<1

右移操作符

逻辑移位
左边用0填充，右边丢弃
2. 算术移位
左边用原该值的符号位填充，右边丢弃

值得注意的是，移动的时候是逻辑移位还是算术移位，是取决于编译器的，真正的运算逻辑与左移位操作符类似

位操作符

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数。

这里的位指的是二进制的位

&按位与计算的是补码，同1为1，其余为0
|按位或有一个1得1，无得0
^按位异或，相同为0，相异为1

我们直接用代码说话

int main()
{
	int a = 3;
	//00000000000000000000000000000011
	int b = -5;
	//10000000000000000000000000000101 原码
	//11111111111111111111111111111010 反码
	//11111111111111111111111111111011 补码
	int c = a | b;
	//00000000000000000000000000000011
	//11111111111111111111111111111011 补码
	
	//11111111111111111111111111111011 补码
	//10000000000000000000000000000100 取反
	//10000000000000000000000000000101	+1
	int d = a & b;
	//00000000000000000000000000000011
	//11111111111111111111111111111011 补码
	//00000000000000000000000000000011
	printf("%d %d", c, d);
	return 0；
	}

如上图代码，我们可以知道操作符在计算的时候是不会保留你的符合位的，（3码保留）。这些操作符都是操作补码的，如果你最后得到的运算结果，符合位为0就不需要再转原码了，反之需要转原码。如d的运算。

在我们学习了位操作符后，我们就可以不用创建临时变量，达到交换2数的问题了。大家有兴趣可以实践一下

//交换2数
int main()
{
	int a = 3;
	int b = 4;
	printf("%d %d\n", a, b);
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("%d %d", a, b);
	return 0;
}

这种方法是基于异或支持交换律上实现的。并且2数相同异或为0，0异或任何数等于任何数。

在这里插入图片描述
值得注意的是这样用异或交换2数有2局限性
1.只能交换整数。
2.可读性差。

赋值操作符

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。

这里我们不作过多停留，注意一下复合赋值操作符即可（对自己操作）

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

单目操作符

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

#include <stdio.h>
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;

这里我们简单留意一下我们的~(按位取反)，也是操作补码的

while (~scanf("%d", &n))

这里的意思是，scanf读取失败就不执行语句
因为，scanf读取失败返回的是EOF（-1），再将-1按位取反

//10000000000000000000000000000001 	原码
//11111111111111111111111111111110	反码
//11111111111111111111111111111111	补码
//00000000000000000000000000000000	按位取反

关系操作符

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

这里的关系操作符也没有什么可讲的，值得注意的就是=与==的区别

逻辑操作符

&& 逻辑与
|| 逻辑或

ok，大家肯定觉得这里也可以跳过了，但是千万不要小瞧逻辑操作符
我们以题为例

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}
//程序输出的结果是什么？

其实在 i = a++ && ++b && d++;里答案输出的是 1234。
在i = a++||++b||d++;，里输出的是1334

这是因为
&& 从左至右来看，遇到一个假，后面就不用看了。
|| 从左至右来看，遇到一个真，后面就不用看了。
这就是逻辑操作符的短路

以后在写循环的时候注意判端用哪个哦

条件操作符

exp1 ? exp2 : exp3

条件操作符的运算逻辑是，表达式exp1是否为真，为真取exp2，为假取exp3。这里我们思考一下用条件操作符怎么写

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

逗号表达式

exp1, exp2, exp3, …expN

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

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//c是多少？

在逗号表达式中，我们不能直接跳过前面的去看最后一个表达式的值来判断，因为有可能前面的表达式会影响后面的表达式。

值得注意的是arr[]={1,2,3,（1，2）}；arr数组里面有4个元素。（逗号表达式得出2）

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

1.下标引用操作符 [ ]
操作数：一个数组名 + 一个索引值

最常见的就是访问数组元素

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

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

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

访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名

#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;
}

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整数提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长
度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令
中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转
换为int或unsigned int，然后才能送入CPU去执行运算。

如图，整型提升针对char与short来说的，在运算的时候会提升为整型

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


//实例1
int main()
{
	char a = 0xb6;
	short b = 0xb600;
 	int c = 0xb6000000;
 	if(a==0xb6)
	 printf("a");
	if(b==0xb600)
	 printf("b");
	if(c==0xb6000000)
	 printf("c");
	 return 0;
}

实例1中的a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a=0xb6 , b=0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真。

ok，这里再给大家了解一下整型提升的例子

int main()
{
	char a = 1;
	//00000000000000000000000000000001
	//00000001		//截断char为8bit位	

	char b = -3;
	//10000000000000000000000000000011
	//11111111111111111111111111111100
	//11111111111111111111111111111101
	//11111101;		

	int c = a + b;
	//11111110		//截断的数操作
	//11111111111111111111111111111110		//补齐按头位 再转原码
	//10000000000000000000000000000001
	//10000000000000000000000000000010
	printf("%d", c);
	return 0;
}

那么我们怎么跟清晰的知道如何发生整型提升了呢，实现下图代码！

int main()
{
	char a = 5;
	char b = 6;
	printf("%u", sizeof(a));
	printf("%u", sizeof(a+b));
	printf("%u", sizeof(+a));		//+a也是表达式
	return 0;
}

算术转换

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

long double
double
float
unsigned long int
long int
unsigned int
int

我们的整型提升是针对小于int类型的，我们的算术转换是针对大于等于int类型的

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

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

到这里就结束了，感谢耐心观看，如果有帮助到你，点给关注吧。