本章内容不是很多,也不是很难,但是有很多零散的知识点需要多练习、多记忆,不用小看每一个操作符,它们都是独一无二的,都很重要,就像我们每个人一样,都发挥着不可替代的作用。
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语言都不一定能学完,抓住一切时间。