C语言中的操作符(万字详解)
- 一、算术操作符()
- 1.除号 /
- 2.取余 %
- 二、移位操作符
- 1.原码
- 2.反码
- 3.补码
- 4.左移操作符
- 5.右移操作符
- 三、位操作符
- 1.按位与操作符:&
- 2.按位或操作符:|
- 3.按位异或操作符:^
- 四、赋值操作符
- 1.连续赋值容易使人误解,建议分开赋值
- 2.复合赋值符
- 五、单目操作符
- 1.单目操作符介绍
- 1.1逻辑反操作:!
- 2.2取地址:&
- 1.3操作数的类型长度(以字节为单位):sizeof
- 1.4按位取反:~
- 1.5前置、后置++
- 1.6前置、后置--
- 六、关系操作符
- 七、逻辑操作符
- 八、条件操作符(三目操作符)
- 九、逗号表达式
- 十、下标引用、函数调用和结构成员
- 1. [ ] 下标引用操作符
- 2. ( ) 函数调用操作符
- 3. 访问一个结构的成员
【前言】
- 操作符的种类比较多,也是我们在敲代码过程中很常用的知识点,里面有很多重点内容和易错的地方,所以还请大家要十分专注,不要遗漏任何一处!
- 希望通过这篇博客,你能够有所收获,能够得到进一步的提升,这才是最主要的!下面让我们来一起看一看吧。😉
一、算术操作符()
+ - * / %
加 减 乘 除 余
这里重点介绍 / 和 %
1.除号 /
对于 / 操作符如果两个操作数都为整数,执行整数除法。而只要有浮点数执行的就是浮点数除法。
代码示例:
#include<stdio.h>
int main()
{
int m = 7 / 2;
double n = 7.0 / 2.0;
printf("m=%d\n", m);
printf("n=%lf\n", n);
return 0;
}
代码结果:
m=3
n=3.500000
2.取余 %
- % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
- 除了 % 操作符之外,其他的几个操作符可以作用于整数和浮点数。
代码示例:
#include<stdio.h>
int main()
{
int m = 7 % 2;
printf("m=%d",m);
return 0;
}
运行结果:
m=1
二、移位操作符
左移操作符:<<
右移操作符:>>
注:
- 移位操作符的操作数只能是整数。
- 对于移位操作符,不要移动负数位,这个是标准为定义的
代码示例:
int a = 10;
int b = a >> -2;//error
那移位操作符怎么移位的呢?
其实"位"是指二进制位,所以移位操作符是指移动一个数的二进制位.
说到二进制数,就不得不提到三种表示形式:原码、补码、反码
那原码、补码、反码的二进制表示形式是什么呢?
首先,无论是原码反码还是补码,它们都是由符号位和数值位组成的,一般将最高位作为符号位,用‘0’表示正数,‘1’表示负数。
1.原码
正数
5
二进制表示:00000101
原码:00000000 00000000 00000000 00000101
负数
-5
二进制表示:10000101
原码:10000000 00000000 00000000 00000101
2.反码
正数的反码和原码相等
负数:原码除符号位全部变成相反数(0-1)
-5
反码11111111 11111111 11111111 11111010
3.补码
正数的原码、反码、补码相等
负数:在反码的基础上加1
-5
补码:11111111 11111111 11111111 11111011
4.左移操作符
移位规则:
左边抛弃、右边补0
正数
代码示例:
#include<stdio.h>
int main()
{
int m = 10;
//原码:00000000 00000000 00000000 00001010
int n = m << 1;
printf("n=%d",n);
return 0;
}
代码结果:
n=20
结果分析:
原码: 00000000000000000000000000001010
移动后的补码: 00000000000000000000000000000101 0
如图所示,m向左偏移1位相当于其原码向左移动一位,移出去的0去掉,在右边补上个0,因为正数的原码、反码、补码相同,所以移位后的补码为0000 0000 00000000 00000000 00010100
化为十进制数为20
负数
代码示例:
#include<stdio.h>
int main()
{
int m = -10;
//原码:10000000 00000000 00000000 00001010
int n = m << 1;
printf("n=%d",n);
return 0;
}
代码结果:
n=-20
结果分析:
原码:10000000000000000000000000001010
反码:11111111111111111111111111110101
补码:11111111111111111111111111110110
移动后的补码: 11111111111111111111111111110110 0
反码:11111111111111111111111111111011
原码:10000000000000000000000000000100
如图所示,m向左偏移1位相当于其原码向左移动一位,移出去的1去掉,在右边补上个0,算得移动后的原码为10000000000000000000000000000100
化为10进制数是**-20**
5.右移操作符
移位规则:
首先右移运算分两种:
1. 逻辑移位
左边用0填充,右边丢弃
2. 算术移位(常用)
左边用原该值的符号位填充,右边丢弃
正数
逻辑移位
代码示例:
#include<stdio.h>
int main()
{
int m = 10;
//原码:00000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d",n);
return 0;
}
代码结果:
n=5
结果分析:
10原码:00000000000000000000000000001010
移动后的补码: 00000000000000000000000000000101 0
如图所示,m向右偏移1位相当于其原码向右移动一位,移出去的0去掉,在左边补上个0,因为正数的原码、反码、补码相同,所以移动后的原码为:00000000000000000000000000000101
化为10进制数是5
算术移位
代码示例:
#include<stdio.h>
int main()
{
int m = 10;
//原码:00000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d",n);
return 0;
}
代码结果:
n=5
结果分析:
10原码:00000000000000000000000000001010
移动后的补码: 00000000000000000000000000000101 0
如图所示,m向右偏移1位相当于其原码向右移动一位,移出去的0去掉,在左边补上个0,因为正数的原码、反码、补码相同,所以移动后的原码为:00000000000000000000000000000101
化为10进制数是5
总结:正数的逻辑移位和算术移位的结果相等
负数
逻辑移位
代码示例:
#include<stdio.h>
int main()
{
int m = -10;
//原码:10000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d", n);
return 0;
}
代码结果:
n=5
结果分析:
-10原码:10000000000000000000000000001010
反码:11111111111111111111111111110101
补码:11111111111111111111111111110110
移动后的补码: 01111111111111111111111111111011 0
反码:01111111111111111111111111111010
原码:00000000000000000000000000000101
如图所示,m向右偏移1位相当于其原码右移动一位,移出去的0去掉,在左边边补上个0,算得移动后的原码为00000000000000000000000000000101
化为10进制数是5
算术移位
代码示例:
#include<stdio.h>
int main()
{
int m = -10;
//原码:10000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d", n);
return 0;
}
代码结果:
n=-5
结果分析:
-10原码:10000000000000000000000000001010
反码:11111111111111111111111111110101
补码:11111111111111111111111111110110
移动后的补码: 11111111111111111111111111111011 0
反码:11111111111111111111111111111010
原码:10000000000000000000000000000101
如图所示,m向右偏移1位相当于其原码右移动一位,移出去的0去掉,在左边边补上个1,算得移动后的原码为10000000000000000000000000000101
化为10进制数是**-5**
总结:负数的逻辑移位和算术移位的结果互为相反数
综上所述:
算术右移:左边用原该值的符号位填充
逻辑右移:左边补0
左移操作符不存在逻辑移位
VS2019编译环境下支持算术移位
三、位操作符
位操作符有:
& //按位与
| //按位或
^ //按位异或
注!!!
他们的操作数必须是整数
同样这里的位也是指二进制位.
1.按位与操作符:&
按位与操作符的计算方法:
- 只有两边的操作数都为真的时候才为真,否则都为假.
- 即二进制对应的位置都为1时取1,否则都为0
正数
代码示例:
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
int num3 = num1 & num2;
printf("num3=%d",num3);
return 0;
}
代码结果:
num3=0
结果分析:
1补码:00000000000000000000000000000001
2补码:00000000000000000000000000000010
1&2补码:00000000000000000000000000000000 //0
2.按位或操作符:|
按位或操作符的计算方法:
只要一边为真则为真。
即二进制对应的位置有1时取1,否则为0。
代码示例:
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
int num3 = num1 | num2;
printf("num3=%d",num3);
return 0;
}
代码结果:
num3=3
结果分析:
1补码:00000000000000000000000000000001
2补码:00000000000000000000000000000010
1|2补码:00000000000000000000000000000011//3
3.按位异或操作符:^
按位或操作符的计算方法:
相同为假,相异为真。
即二进制对应位置相同则取0;反之,则为1。
代码示例:
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
int num3 = num1 ^ num2;
printf("num3=%d",num3);
return 0;
}
代码结果:
num3=3
结果分析:
1补码:00000000000000000000000000000001
2补码:00000000000000000000000000000010
1|2补码:00000000000000000000000000000011//3
按位异或操作符推广:实现两个数的交换。(不能创建临时变量)
代码示例:
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
a = a^b;//10^20
b = a^b;//10^20^20=10^0=10
a = a^b;//10^20^10=10^10^20=0^20=20
printf("a = %d b = %d\n", a, b);
return 0;
}
代码结果:
a=20 b=10
小结:
异或操作符满足交换律
四、赋值操作符
赋值操作符是一个很棒的操作符,他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。
代码示例:
int weight = 120;
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。
这里需要注意的是
1.连续赋值容易使人误解,建议分开赋值
代码示例:
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值
这样的代码感觉怎么样?
那同样的语义,你看看:
x = y+1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。
2.复合赋值符
代码示例:
#include <stdio.h>
int main()
{
int a = 2, b = 3;
a += b;//a=a+b
a -= b;//a=a-b
a *= b;//a=a*b
a /= b;//a=a/b
a %= b;//a=a%b
a >>= b;//a=a>>b
a <<= b;//a=a<<b
a &= b;//a=a&b
a |= b;//a=a|b
a ^= b;//a=a^b
return 0;
}
五、单目操作符
1.单目操作符介绍
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度(以字节为单位)
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符(解引用操作符)
(类型) 强制类型转换
1.1逻辑反操作:!
将逻辑结果取反,即真的变为假的,假的变为真的
在c语言中,0为假,非0为真
代码示例:
#include <stdio.h>
int main()
{
int a = 1;
int b = 0;
printf("a=%d\n", !a);//0
printf("b=%d", !b);//1
return 0;
}
2.2取地址:&
用于得到变量,数组等的地址
在C语言中,变量,常量字符串,数组,结构体包括指针等在内存中都是有地址的,需要在内存中分配一块空间来存储这些值,而内存的编号就是内存地址
但是字面常量(如常数 6)在内存中是没有地址的,因为它本身并不需要在保存下来
代码示例:
#include <stdio.h>
int main()
{
int a = 1;
printf("%p",&a);
return 0;
}
代码结果:
0133F800
结果分析:
确实是取地址
1.3操作数的类型长度(以字节为单位):sizeof
sizeof()用于计算操作数所占空间大小,单位是字节,可以以类型、指针、数组和函数等作为参数。
返回值类型为unsigned int
代码示例:
#include <stdio.h>
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;
}
代码结果:
40
10
4
4
结果分析:
我们知道,在数据类型篇已经了解c语言中各数据类型占用多少字节.
所以当sizeof(数组名)操作符在计算不同类型的数组的时候.得到的结果不同,为相应数组中元素总>和所占用的字节数.
当我们在数组传参时,传的是数组首元素的地址,而计算地址的大小只有两种结果
总结:
数组名一般表示的是数组首元素的地址,但有两个情况是例外的!
1.sizeof(数组名)——这里数组名表示的是整个数组,用于计算整个数组所占空间的大小
2.&数组名-----这里的数组名表示的是整个数组,即这里取的是整个数组的地址
数组+1:
1.4按位取反:~
代码示例:
#include <stdio.h>
int main()
{
int a = 7;
printf("~a=%d", ~7);
return 0;
}
代码结果:
~a=-8
结果分析:
7补码:00000000000000000000000000000111
~7补码:11111111111111111111111111111000
~7反码:11111111111111111111111111110111
~7原码:10000000000000000000000000001000//-8
1.5前置、后置++
代码示例:
#include <stdio.h>
int main()
{
int a = 10;
int b = 10;
int x = ++a;//先对a进行自增,再使用a
int y = b++;//先使用b,再对b进行自增
printf("x=%d y=%d",x,y);
return 0;
}
代码结果:
x=11 y=10
1.6前置、后置–
代码示例:
#include <stdio.h>
int main()
{
int a = 10;
int b = 10;
int x = --a;//先对a进行自减,再使用a
int y = b--;//先使用b,再对b进行自减
printf("x=%d y=%d",x,y);
return 0;
}
代码结果:
x=9 y=10
六、关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
这些关系运算符比较简单,没什么可讲的,但是我们要注意一些运算符使用时候的陷阱。
警告:
在编程的过程中== 和=不小心写错,导致的错误。
七、逻辑操作符
&& 逻辑与
|| 逻辑或
它们分别为两个按位与(&)和两个按位或(|)组成,它们的效果是一样的,但它们的作用对象不同:
- &&(逻辑与):表示操作符两边的操作符都为’真’是才为’真’,否则都为’假’
- | | (逻辑或):只要有一个为’真’,则为’真’,否则都为’假’
- 并不是对二进制位进行运算.
区分逻辑与和按位与
区分逻辑或和按位或
代码示例:
#include<stdio.h>
int main()
{
int a = 1&2;//0
int b = 1&&2;//1
int c = 1|2;//3
int d = 1||2;//1
return 0;
}
重点来了!!!
一道360笔试题:
例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 i=%d", a, b, c, d,i);
return 0;
}
例2:
#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 i=%d", a, b, c, d,i);
return 0;
}
代码结果:
例1:
a=1
b=2
c=3
d=4
i=0
例2:
a=1
b=3
c=3
d=4
i=1
结果分析:
例1
- a++是后置++,所以表达式a++在使用时是0,故表达式左边结果为假
- 即整个a++ && ++b && d++;语句为假,不执行后面的++b和d++操作
- 最后:a自增1(后置++),故结果为,a+1=1,b,c,d值不变
例2
- 同样a++是后置++,所以表达式a++在使用时是0,故表达式左边结果为假
- 但是逻辑与会继续执行表达式++b,则表达式++b的结果为真,则整个表达式
- a++||++b||d++;的结果为真,并不会继续执行d++
- 最终:a+1,b+1,d和c不变
八、条件操作符(三目操作符)
exp1 ? exp2 : exp3
当我们要输出两个数的较大数时,通常使用if语句完成:
#include <stdio.h>
int main()
{
int a = 0, b = 0;
scanf("%d %d", &a, &b);
if (a > b)
{
printf("%d", a);
}
else printf("%d", b);
return 0;
}
其实我们可以转换为较为简单的写法,条件表达式写法:
#include <stdio.h>
int main()
{
int a = 0, b = 0;
scanf("%d %d", &a, &b);
a > b ? printf("%d", a) : printf("%d", b);
return 0;
}
九、逗号表达式
exp1, exp2, exp3, …expN
1.逗号表达式,就是用逗号隔开的多个表达式。
2.逗号表达式,从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
代码示例:
#include<stdio.h>
{
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);
printf("c=%d",c)
return 0;
}
代码结果:
c=13
灵活运用逗号表达式
逗号表达式实际使用时的妙处:
#include <stdio.h>
int main()
{
int a = 3, b = 5, c = 0;
b=dispose1(a);//函数处理1
c=dispose2(b);//函数处理2
while (c > 0)
{
//这里是一段业务处理
b = dispose1(a);//函数处理1
c = dispose2(b);//函数处理2
}
return 0;
}
改为逗号表达式之后:
#include <stdio.h>
int main()
{
int a = 3, b = 5, c = 0;
while (b = dispose1(a), c = dispose2(b),c > 0)
{
//这里是一段业务处理
}
return 0;
}
十、下标引用、函数调用和结构成员
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();//实用()作为函数调用操作符。
test2("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;
}
【最后】
有关操作符还有最后一个隐式类型转换,因为这部分知识点还是比较重要的,所以我们留到下一篇文章仔细讲解,大家可以订阅我的专栏,这样大家就可以第一时间收到我发的文章啦!
好了,c语言中,有关操作符的知识就讲到这里了,希望对大家有所帮助!🎉