C语言操作符

本章内容不是很多，也不是很难，但是有很多零散的知识点需要多练习、多记忆，不用小看每一个操作符，它们都是独一无二的，都很重要，就像我们每个人一样，都发挥着不可替代的作用。

1.操作符分类

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

2.算术操作符

+     -     *     /     %

tips：

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

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

#include<stdio.h>
int main()
{
//int a = 6 / 5;
//printf("%d\n",a);//结果为1

float a = 6.0 / 5;
printf("%f\n",a);//结果为1.2（只要有一个浮点数，执行的就是浮点数除法）
return 0;
}

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

3.移位操作符

<<  左移操作符

>>  右移操作符

tips:移位操作符的操作数只能是整数

3.1 <<  左移操作符

移位规则：（二进制位）左边抛弃，右边补零

#include<stdio.h>
int main()
{
int a = 10;
int b = a << 1;
//00000000000000000000000000001010 - a 在内存中的二进制
//00000000000000000000000000010100 - b = 20
printf("b = %d",b);
}

3.2 右移操作符

右移操作符有两种：

1.逻辑移位：右丢弃，左补零

2.算术移位：右丢弃，左边用原该值的符号位（二进制位的第一位为符号位，整数符号位为0，负数为1）补齐

整数（针对负数）的二进制位表示形式有三种：

1.原码：直接根据数值写出的二进制序列

2.反码：原码的符号位（第一位）不变，其他位按位取反

3.补码：反码+1

对于正数，原码、反码、补码相同

例：-1

原码：10000000000000000000000000000001（第一个1表示-）

反码：1111111111111111111111111111111111110

补码：1111111111111111111111111111111111111

负数以补码的形式在内存中存储

例：

#include<stdio.h>
int main()
{
int a = -1;
//1111111111111111111111111111111111111 - -1在内存中的表示
int b = a >> 1;

printf("%d\n",b);//结果为-1，说明当前右移操作符使用的是算术右移
return 0;
}

注意：对于移位操作符，不要移动负位数，这是标准未定义的。

4.位操作符

1.& - 按位与

规则：1&1=1；1&0=0；0&1=0；0&0=0；两位同时为‘1’，结果才为‘1’，否则为‘0’。

2.| - 按位或

规则：两位有一位为‘1’，结果就为‘1’，否则为0；

3.^ - 按位异或

规则：（1）0^0 = 0;1^0 = 1;0异或任何数=任何数本身

（2）1^1 = 0;1^0 = 1;1异或任何数=任何数取反

（3）任何数异或自己 = 把自己置0

tips:它们的操作数必须是整数

例：

#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
int c = a & b;
printf("%d\n",c);
//00000000000000000000000000000011 - a
//00000000000000000000000000000101 - b
//00000000000000000000000000000001 - a & b = 1
//00000000000000000000000000000111 - a | b = 7
//00000000000000000000000000000110 - a ^ b = 6(相同为0，相异为1，两个相同数字异或为0)
return 0;
}

练习：1.两个数字交换

#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
printf("a = %d b = %d\n",a,b);
int tmp = a;
a = b;
b = tmp;
printf("a = %d b = %d\n",a,b);
}

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

法①

#include<stdio.h>
int main()//存在数值太大会溢出的问题
{
int a = 3;
int b = 5;
a = a + b;
b = a - b;
a = a - b;
printf("a=%d b=%d\n", a, b);
return 0;
}

法②

#include<stdio.h>
int main()
{
int a = 3;//00000000000000000000000000000011--a
int b = 5;//00000000000000000000000000000101--b
a = a ^ b;//00000000000000000000000000000110--a 
b = a ^ b;//00000000000000000000000000000011--b
a = a ^ b;//00000000000000000000000000000101--a
return 0;
}

练习3.求一个整数存储在内存中的二进制中1的个数

#include<stdio.h>
int main()
{
int a = 13;
int i = 0;
int count = 0;
for(i = 0;i < 32;i++)
{
if(a = a & (a >> 1))
count++;
}
printf("count=%d\n",count++);
return 0;
}

5.赋值操作符（=）

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

int a = 10;
int b = 5;
int y = 20;
//a = b = y + 1;//赋值操作符可以连续使用，但这样会给调式带来不便
b = y + 1;
a = b;//这样的写法更加清晰爽朗而且易于调试。

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

例：

int i = 10;
//i = i + 10;
i += 10;//更加简洁，其他复合赋值都类似

6.单目操作符

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

例：~ - 按位取反的使用

#include<stdio.h>
int main()
{
int a = 13;
//将a的二进制位的倒数第五位的0改为1
//0000000000000000000000000001101 - a
//0000000000000000000000000010000 - 1<<4
//0000000000000000000000000011101 - a | (1<<4)
a = a | (1<<4);
printf("%d\n",a);
//再将a的二进制位改回来（二进制位的倒数第五位改为0）
//0000000000000000000000000011101 - 现在的a
//1111111111111111111111111101111 - ~(1<<4) - 按位与a
//0000000000000000000000000010000 - (1<<4)
a = a & (~(1 << 4));
printf("%d\n",a);
return 0;
}

例：！逻辑反

#include<stdio.h>
int main()
{
int flag = 5;
if(flag)//flag为真
printf("haha\n");
if(!flag)//flag为假
printf("hehe\n");
return 0;
}

例：sizeof - 求变量或类型所占空间的大小

#include<stdio.h>
int main()
{
int a = 10;
char arr[10] = {0};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(int));//int 是 a 的类型

printf("%d\n",sizeof(arr));
printf("%d\n",sizeof(char[10]));//char[10]是数组arr的类型
//sizeof后加变量名时可以把左右两边圆括号去掉，后加变量类型时不可以，这也可以说明sizeof是一个操作符，不是函数。
printf("%d\n",sizeof a);//√
printf("%d\n",sizeof int);//×
return 0;
}

#include<stdio.h>
int main()
{
short a = 5;
int b = 10;
printf("%d\n",sizeof(a = b + 2));//结果为2.sizeof括号中的表达式不参与运算
printf("%d\n",a);//结果为5
return 0;
}

#include<stdio.h>
void test1(int arr[])
{
	printf("arr1 = %d\n", sizeof(arr));//(2)数组传参传的是数组首元素地址，指针大小不论类型，大小相同
}

void test2(char ch[])
{
	printf("ch1=%d\n", sizeof(ch));//(4)
}

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

 （1）（2）（3）（4）四个地方输出的结果分别是什么呢？

（1）arr2 = 40       (2)arr1=8/4

  (3)ch2=10             (4)ch1=8/4

例：++ ：前置++（先++，后使用），后置++（先使用，再++）；-- ：前置--，后置--

#include<stdio.h>
int main()
{
int a = 10;
int b = a++;//后置++，先对a使用，再增加，这样b的值是10
int c = ++a;//前置++，先++，后使用，c = 11
printf("%d\n",a++);
printf("%d\n",a);
printf("%d\n",b);
printf("%d\n",c);
return 0;
}

7.关系操作符

> >= < <= !=    “不相等” ==    “相等”

这些关系操作符都比较简单，但要注意使用时的陷阱。

tips: = —  赋值操作符

       == — 判断相等

8.逻辑操作符

&& —— 逻辑与（操作数都为真才真）

||    —— 逻辑或（一个操作数为真就真）

#include<stdio.h>
int main()
{
int a = 3;
int b = 0;
if(a && b)
{
printf("haha\n");
}
if(a || b)
{
printf("hehe\n");
}
return 0;
}

区分逻辑与（&&）和按位与（&），逻辑或（||）和按位或（|）

1&2----->0（按二进制位与）
1&&2---->1
1|2----->3
1||2---->1

#include<stdio.h>
int main()
{
int i = 0,a = 0,b = 2,c = 3,d = 4;
i = a++ && ++b && d++;
printf("a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
j = a++ || ++b || d++;
printf("a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
//它们的结果分别是什么呢？
}

对于 && ，左边为假，右边就不用算了

对于 || ，左边为真，右边就不用算了

9.条件操作符

exp1 ? exp2:exp3

若exp1为真，执行exp2,exp1为假，执行exp3

例：使用条件表达式实现找两个数中较大值

#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
int max = (a > b ? a : b);
printf("%d\n",max);
}

10.逗号表达式

exp1,exp2,……expn;

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

#include<stdio.h>
int main()
{
int a = 3;
int b = 0;
int c = 5;
int d = (b = a + b,c = a + b,b = a + c)
printf("%d\n",d);
return 0;
}

最后一个结果会跟最后一个逗号前面的表达式有关，所以即使不是表达式的结果，最后一个表达式前面的表达式也要计算。

11.下标引用、函数调用、结构成员操作符

1.[] - 下标引用操作符

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

#include<stdio.h>
int main()
{
int arr[] = {1,2,3,4,5,6,7,8,9};
printf("%d\n",arr[4]);//[ ] 的操作数为arr和4
return 0;
}

2.（）- 函数调用操作符

接收一个或多个操作数：第一个操作数是函数名，其余的操作数是传给函数的参数。

#include<stdio.h>
int Add(int x,int y)//函数定义
{
return x + y;
}

int main()
{
int a = 3;
int b = 5;
int sum = Add(a,b);//() - 函数调用操作符
return 0;
}

3.访问结构成员

（1）. - 结构体.成员名

（2）->  结构体指针->成员名

#include<stdio.h>
struct Book//struct - 定义一种新的结构体
{
//结构体成员（变量）
char name[10];
char id[10];
int price;
};//注意：struct - 大括号后面有一个分号

int main()
{
struct Book b = {"C语言"，"d20221125",50};
struct *pb = &b;

printf("书名：%s\n",b.name);// 结构体.成员名
printf("书号：%s\n",b.id);
printf("价格：%d\n",b.price);

printf("书名：%s\n",(*pb).name);// 结构体.成员名
printf("书号：%s\n",(*pb).id);
printf("价格：%d\n",(*pb).price);

printf("书名：%s\n",*pb -> name);// 结构体->成员名
printf("书号：%s\n",*pb -> id);
printf("价格：%d\n",*pb -> price);

return 0;
}

12.表达式求值

表达式求值的顺序一部分由操作符的优先级的结合性决定，有些表达式再求值过程中也可能转换为其他类型。

12.1 隐式类型转换

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

就是说比int类型所占空间小的类型（char,short…）在计算时计算机会悄悄地把它们的类型转换为整型。

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

整型提升规则：按照变量数据类型的符号位提升

1.负数的整型提升

char c1 = -1;

char类型的变量c1的二进制位（补码）中只有8个比特位：11111111

因为 char 为有符号的 char ，所以整型提升时，高位补充符号位，即为1

提升后得：11111111111111111111111111111111

2.正数的整型提升

char c2 = 1;

变量c2的二进制位（补码）中也只有8个比特位：00000001

因为char为有符号的char，高位补充符号位，即为0

提升后得：00000000000000000000000000000001

3.无符号整型提升，高位补0

#include<stdio.h>
int main()
{
int a = 3;
//00000000000000000000000000000011
//00000011 - a(char类型只能存8个比特位)

char b = 127;
//00000000000000000000000001111111 - 127
//01111111 - b

char c = a + b;

//00000000000000000000000000000011 - 整型提升后的a（正数整型提升补符号位）
//00000000000000000000000001111111 - 整型提升后的b
//00000000000000000000000010000010 - a+b 
//c = 10000010,符号位为1，表明c为负数
//11111111111111111111111110000010 - 整型提升后的c的补码
//11111111111111111111111110000001 - 反码（补码-1）
//00000000000000000000000001111110 - 原码C = -126
printf("%d\n",c);
}

int main()
{
char c = 1;
printf("%u\n",sizeof(c));//1
printf("%u\n",sizeof(+c));//4
printf("%u\n",sizeof(-c));//4
}

 

12.2 算术转换

不同类型的操作数进行运算之前，需要将它们转换为相同的类型

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

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

12.3 操作符的属性

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

1.操作符的优先级

2.操作符的结合性

3.是否控制求值顺序（&& ；|| ；？ ：条件操作符；，）

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

但是知道了操作符的优先级、结合性和是否控制求值顺序，也不一定任何表达式都只有一个确定的结果，存在有歧义的表达式。

例：a*b + b*c + c*a

代码在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不
能决定第三个*比第一个+早执行,所以这个表达式有多种不同算法，得出的结果也可能不同。

断断续续写了两天，果然不能小看操作符，有一些东西还是挺不好理解的，等以后有时间再去学一下，把不懂的地方再看看，现在每天好多课，放假之前C语言都不一定能学完，抓住一切时间。