一、操作符的分类
- 算术操作符: + 、- 、* 、/ 、%
- 移位操作符: << >>
- 位操作符: & | ^
- 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
- 单目操作符: !、++、–、&、*、+、-、~ 、sizeof、(类型)
- 关系操作符: > 、>= 、< 、<= 、 == 、 !=
- 逻辑操作符: && 、||
- 条件操作符:? :
- 逗号表达式: ,
- 下标引用: []
- 函数调用: ()
- 结构成员访问: . 、->
hello,宝子们!今天先介绍前半部分操作符,操作符中有一些操作符和二进制有关系,我们先铺垫一下二进制和进制转换的知识。
二、二进制和进制转换
其实我们经常能听到2进制、8进制、10进制、16进制这样的讲法,那是什么意思呢?其实2进制、8进制、10进制、16进制是数值的不同表示形式而已。
比如:数值15的各种进制的表示形式:
15的2进制 :1111
15的8进制 :17
15的10进制:15
15的16进制:F
我们重点介绍一下二进制:
首先我们还是得从10进制讲起,其实10进制是我们生活中经常使用的,我们已经形成了很多尝试:
- 10进制中满10进1
- 10进制的数字每一位都是0~9的数字组成,其实二进制也是一样的
- 2进制中满2进1
- 2进制的数字每一位都是0~1的数字组成,那么 1101 就是二进制的数字了。
1.2进制转10进制
其实10进制的123表示的值是一百二十三,为什么是这个值呢?其实10进制的每⼀位是权重的,10进制的数字从右向左是个位、十位、百位…,分别每一位的权重是 10 ,10 ,10 …
如下图:
2进制和10进制是类似的,只不过2进制的每一位的权重,从右向左是: 2 ,2 ,2 …
如果是2进制的1101,该怎么理解呢?
2.10进制转2进制
3.2进制转8进制
8进制的数字每一位是0到7的,0~7的数字,各自写成2进制,最多有3个2进制位就足够了,比如7的二进制是111,所以在2进制转8进制数的时候,从2进制序列中右边低位开始向左每3个2进制位会换算一个8进制位,剩余不够3个2进制位的直接换算。
如:2进制的01101011,换成8进制:0153,0开头的数字,会被当做8进制。
4.2进制转16进制
16进制的数字每⼀位是0到9,a到f的数字,各自写成2进制,最多有4个2进制位就足够了,比如f的二进制是1111,所以在2进制转16进制数的时候,从2进制序列中右边低位开始向左每4个2进制位会换算一个16进制位,剩余不够4个二进制位的直接换算。
如:2进制的01101011,换成16进制:0x6b,16进制表示的时候前面加0x
三、原码、反码、补码
整数的2进制表示方法有三种,即原码、反码和补码
有符号整数的三种表示方法均有符号位和数值位两部分,2进制序列中,最高位的1位是被当做符号位,剩余的都是数值位。
符号位都是用0表示“正”,用1表示“负”。
正整数的原、反、补码都相同。
负整数的三种表示方法各不相同。
原码: 直接将数值按照正负数的形式翻译成二进制得到的就是原码。
反码: 将原码的符号位不变,其他位依次按位取反就可以得到反码。
补码: 反码+1就得到补码。
反码得到原码也是可以使用:取反,+1的操作。
对于整形来说:数据存放内存中其实存放的是补码。
为什么呢?
在计算机系统中,数值⼀律用补码来表示和存储。原因在于,使用补码,可以将符号位和数值域统一处理;同时,加法和减法也可以统一处理(CPU只有加法器)此外,补码与原码相互转换,其运算过程是相同的,不需要额外的硬件电路。
四、算术操作符+、-、*、/、%
在写代码时候,一定会涉及到计算。
C语言中为了方便运算,提供了一系列操作符,其中有一组操作符叫:算术操作符。分别是: + - */ %
,这些操作符都是双目操作符。
注:操作符也被叫做:运算符,是不同的翻译,意思是一样的。
1.+和-
+
和-
用来完成加法和减法。+
和-
都是有2个操作数的,位于操作符两端的就是它们的操作数,这种操作符也叫双目操作符。
#include <stdio.h>
int main()
{
int x = 4 + 22;
int y = 61 - 23;
printf("%d\n", x);
printf("%d\n", y);
return 0;
}
2.*
运算符 * 用来完成乘法。
#include <stdio.h>
int main()
{
int num = 5;
printf("%d\n", num * num); // 输出 25
return 0;
}
3./
运算符 /
用来完成除法。
除号的两端如果是整数,执行的是整数除法,得到的结果也是整数。
#include <stdio.h>
int main()
{
float x = 6 / 4;
int y = 6 / 4;
printf("%f\n", x); // 输出 1.000000
printf("%d\n", y); // 输出 1
return 0;
}
上面示例中,尽管变量 x
的类型是 float
(浮点数),但是 6 / 4
得到的结果是 1.0
,而不是1.5
。原因就在于C语言里面的整数除法是整除,只会返回整数部分,丢弃小数部分。
如果希望得到浮点数的结果,两个运算数必须至少有一个浮点数,这时C语言就会进行浮点数除法。
#include <stdio.h>
int main()
{
float x = 6.0 / 4; // 或者写成 6 / 4.0
printf("%f\n", x); // 输出 1.500000
return 0;
}
上面示例中, 6.0 / 4
表示进行浮点数除法,得到的结果就是 1.5
。
再看⼀个例子:
#include <stdio.h>
int main()
{
int score = 5;
score = (score / 20) * 100;
return 0;
}
上面的代码,你可能觉得经过运算, score
会等于 25
,但是实际上 score
等于 0
。这是因为score / 20
是整除,会得到⼀个整数值 0
,所以乘以 100
后得到的也是 0
。
为了得到预想的结果,可以将除数 20
改成 20.0
,让整除变成浮点数除法。
#include <stdio.h>
int main()
{
int score = 5;
score = (score / 20.0) * 100;
return 0;
}
4.%
运算符 %
表示求模运算,即返回两个整数相除的余值。这个运算符只能用于整数,不能用于浮点数。
#include <stdio.h>
int main()
{
int x = 6 % 4; // 2
return 0;
}
负数求模的规则是,结果的正负号由第⼀个运算数的正负号决定。
#include <stdio.h>
int main()
{
printf("%d\n", 11 % -5); // 1
printf("%d\n",-11 % -5); // -1
printf("%d\n",-11 % 5); // -1
return 0;
}
上面示例中,第⼀个运算数的正负号( 11
或 -11
)决定了结果的正负号。
五、移位操作符
注:移位操作符的操作数只能是整数。
1.左移操作符
移位规则:左边抛弃、右边补0
#include <stdio.h>
int main()
{
int num = 10;
int n = num<<1;
printf("n= %d\n", n);
printf("num= %d\n", num);
return 0;
}
2.右移操作符
移位规则:首先右移运算分两种:
1.逻辑右移:左边用0填充,右边丢弃
2.算术右移:左边用原该值的符号位填充,右边丢弃
#include <stdio.h>
int main()
{
int num = 10;
int n = num>>1;
printf("n= %d\n", n);
printf("num= %d\n", num);
return 0;
}
警告⚠ :对于移位运算符,不要移动负数位,这个是标准未定义的。
例如:
int num = 10;
num>>-1; //error
六、位操作符:&、|、^、~
位操作符有:
- & 按位与:双目操作符,参与运算的两个值,转换成2进制,如果两个相应位均为1时,结果位才为1,否则为0。
- | 按位或:双目操作符,参与运算的两个值,转换成2进制,如果两个数的相应位有1时,结果就为1。
- ^ 按位异或:双目操作符,参与运算的两个值,转换成2进制,如果两个数的相应位相同,为0,否则为1.
- ~ 按位取反:单目操作符,参与运算的一个值,转换成2进制,可以将二进制数每个位取反,即0变为1,1变为0。
注:他们的操作数必须是整数。
直接上代码:
#include <stdio.h>
int main()
{
int num1 = -3;
int num2 = 5;
printf("%d\n", num1 & num2);
printf("%d\n", num1 | num2);
printf("%d\n", num1 ^ num2);
printf("%d\n", ~0);
return 0;
}
下来看一道变态的面试题:
不能创建临时变量(第三个变量),实现两个数的交换。
相信这道题目大家都会,但是来见证一下更加新奇的一种思路吧,一定会让你脑洞大开的。
#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;
}
练习1: 编写代码实现:求一个整数存储在内存中的二进制中1的个数。
参考代码:
//⽅法1
#include <stdio.h>
int main()
{
int num = 10;
int count= 0; //计数
while(num)
{
if(num%2 == 1)
count++;
num = num/2;
}
printf("⼆进制中1的个数 = %d\n", count);
return 0;
}
//思考这样的实现方式有没有问题?
//⽅法2:
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0; //计数
for(i=0; i<32; i++)
{
if( num & (1 << i) )
count++;
}
printf("⼆进制中1的个数 = %d\n",count);
return 0;
}
//思考还能不能更加优化,这⾥必须循环32次的。
//⽅法3:
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0; //计数
while(num)
{
count++;
num = num&(num-1);
}
printf("⼆进制中1的个数 = %d\n",count);
return 0;
}
//这种⽅式是不是很好?达到了优化的效果,但是难以想到。
练习2:二进制位置0或者置1
编写代码将13⼆进制序列的第5位修改为1,然后再改回0
13的2进制序列: 00000000000000000000000000001101
将第5位置为1后:00000000000000000000000000011101
将第5位再置为0:00000000000000000000000000001101
参考代码:
#include <stdio.h>
int main()
{
int a = 13;
a = a | (1<<4);
printf("a = %d\n", a);
a = a & ~(1<<4);
printf("a = %d\n", a);
return 0;
}
七、赋值操作符:=和复合赋值
在变量创建的时候给一个初始值叫初始化,在变量创建好后,再给一个值,这叫赋值。
int a = 100; //初始化
a = 200; //赋值,这⾥使⽤的就是赋值操作符
赋值操作符 =
是一个随时可以给变量赋值的操作符。
1.连续赋值
赋值操作符也可以连续赋值,如:
int a = 3;
int b = 5;
int c = 0;
c = b = a+3; //连续赋值,从右向左依次赋值的。
C语言虽然支持这种连续赋值,但是写出的代码不容易理解,建议还是拆开来写,这样方便观察代码的执行细节。
int a = 3;
int b = 5;
int c = 0;
b = a+3;
c = b;
这样写,在调试的是,每一次赋值的细节都是可以很方便的观察的。
2.复合赋值符
在写代码时,我们经常可能对一个数进行自增、自减的操作,如下代码:
int a = 10;
a = a+3;
a = a-2;
这样代码C语言给提供了更加方便的写法:
int a = 10;
a += 3;
a -= 2;
C语言中提供了复合赋值符,方便我们编写代码,这些赋值符有:
+= -=
*= /= %=
>>= <<=
&= |= ^=
八、 单目操作符
1.逻辑反操作符 !
比如,我们有一个变量叫 flag
,如果flag为假,要做⼀个什么事情,就可以这样写代码:
#include <stdio.h>
int main()
{
int flag = 0;
if(!flag)
{
printf("do something\n");
}
return 0;
}
如果 flag
为真, !flag
就是假,如果 flag
为假, !flag
就是真所以上面的代码的意思就是 flag
为假,执行if
语句中的代码。
2.自增和自减操作符 ++、–
++是一种自增的操作符,又分为前置++和后置++,–是一种自减的操作符,也分为前置–和后置–。
前置++
int a = 10;
int b = ++a; //++的操作数是a,是放在a的前⾯的,就是前置++
printf("a=%d b=%d\n",a , b);
计算口诀: 先+1,后使用
a原来是10,先+1,后a变成了11,再使用就是赋值给b,b得到的也是11,所以计算技术后,a和b都是11,相当于这样的代码:
int a = 10;
a = a+1;
b = a;
printf("a=%d b=%d\n",a , b);
后置++
int a = 10;
int b = a++; //++的操作数是a,是放在a的后⾯的,就是后置++
printf("a=%d b=%d\n",a , b);
计算口诀: 先使用,后+1
a原来是10,先使用,就是先赋值给b,b得到了10,然后再+1,然后a变成了11,所以直接结束后a是11,b是10,相当于这样的代码:
int a = 10;
int b = a;
a = a+1;
printf("a=%d b=%d\n",a , b);
前置–
如果你听懂了前置++,那前置–是同理的,只是把加1,换成了减1;
计算口诀: 先-1,后使用
int a = 10;
int b = --a; //--的操作数是a,是放在a的前⾯的,就是前置--
printf("a=%d b=%d\n",a , b); //输出的结果是:9 9
后置–
同理后置–类似于后置++,只是把加一换成了减一
计算口诀:先使用,后-1
int a = 10;
int b = a--; //--的操作数是a,是放在a的后⾯的,就是后置--
printf("a=%d b=%d\n",a , b); //输出的结果是:9 10
3.取地址操作符 & 与解引用操作符 *
(1)取地址操作符
我们想要知道某变量的地址时,就可以使用 &
得到。
看一段代码
#include <stdio.h>
int main()
{
int a=1;
printf("%p,"&a);
return 0;
}
a变量创建的本质是:
在内存上开辟空间,向内存申请4个字节的空间,存放数据1,且每个字节都有地址,&a
取出来的是a
所占四个字节中地址较小的字节的地址。
整型变量占了4个字节,现在我们只知道第一个字节的地址,但是我们可以顺着下去找出该变量其他字节的地址,然后访问到这些地址的数据
(2)指针变量
指针变量是用来存储地址的,因为地址也是一个数值,后期可能要经常使用。
#include <stdio.h>
int main()
{
int a=1;
int*pa=&a;
return 0;
}
取出a
的地址存储到指针变量pa
中,单看 int* pa=&a
,*
说明 pa
是指针变量int
说明 pa
指向的是整型类型对象,也就是a的数据类型,int*
是pa
的数据类型。
(3)解引用操作符
解引用操作符 *
可以通过指针变量存储的地址找到地址指向的对象。
#include <stdio.h>
int main()
{
int a=1;
int*pa=&a;
*pa=0;
return 0;
}
*pa=0
;这里就用了解引用操作符,通过pa
指针变量存储的地址找到了a
,所以 *pa
就是a
,也就是将0
赋值给了a
。学习这个之后,我们之后就可以灵活地运用解引用操作符解决很多问题了。
4.正负号操作符+、-
这里的+是正号,-是负号,都是单目操作符。
运算符 +
对正负值没有影响,是一个完全可以省略的运算符,但是写了也不会报错。
int a = +10; 等价于 int a = 10;
运算符-
用来改变一个值的正负号,负数的前面加上 -
就会得到正数,正数的前⾯加上 -
会得到负数。
int a = 10;
int b = -a;
int c = -10;
printf("b=%d c=%d\n", b, c); //这⾥的b和c都是-10
int a = -10;
int b = -a;
printf("b=%d\n", b); //这⾥的b是10
5.sizeof操作符
sizeof
是一个关键字,也是操作符,专门是用来计算sizeof的操作数的类型长度的,单位是字节。sizeof
操作符的操作数可以是类型,也可以是变量或者表达式。
sizeof( 类型 )
sizeof 表达式
sizeof
的操作数如果不是类型,是表达式的时候,可以省略掉后边的括号的。sizeof
后边的表达式是不真实参与运算的,根据表达式的类型来得出大小。sizeof
的计算结果是 size_t 类型的。
📌
sizeof
运算符的返回值,C语⾔只规定是无符号整数,并没有规定具体的类型,而是留给系统自己去决定,sizeof
到底返回什么类型。不同的系统中,返回值的类型有可能是unsigned int
,也有可能是unsigned long
,甚⾄是unsigned long long
,对应的printf()
占位符分别是%u
、%lu
和%llu
。这样不利于程序的可移植性。C语言提供了一个解决方法,创造了一个类型别名size_t
,用来统一表示sizeof
的返回值类型。对应当前系统的sizeof
的返回值类型,可能是unsigned int
,也可能是unsigned long long
。
比如:
#include <stdio.h>
int main()
{
int a = 10;
printf("%zd\n", sizeof(a));
printf("%zd\n", sizeof a); //a是变量的名字,可以省略掉sizeof后边的()
printf("%zd\n", sizeof(int));
printf("%zd\n", sizeof(3 + 3.5));
return 0;
}
数据类型长度
#include <stdio.h>
int main()
{
printf("%zd ", sizeof(char));
printf("%zd ", sizeof(_Bool));
printf("%zd ", sizeof(short));
printf("%zd ", sizeof(int));
printf("%zd ", sizeof(long));
printf("%zd ", sizeof(long long));
printf("%zd ", sizeof(float));
printf("%zd ", sizeof(double));
printf("%zd ", sizeof(long double));
return 0;
}
在VS2022X64配置下的输出:
1 1 2 4 4 8 4 8 8
sizeof中表达式不计算
//测试:sizeof中表达式不计算
#include <stdio.h>
int main()
{
short s = 2;
int b = 10;
printf("%d\n", sizeof(s = b+1));
printf("s = %d\n", s);
return 0;
}
sizeof 在代码进行编译的时候,就根据表达式的类型确定了大小,而表达式的执行却要在程序运行期间才能执行,在编译期间已经将sizeof处理掉了,所以在运行期间就不会执行表达式了。
6.强制类型转换(类型)
在操作符中还有一种特殊的操作符是强制类型转换,语法形式很简单,形式如下:
(类型)
请看代码:
int a = 3.14;
//a是int类型, 3.14是double类型,两边的类型不⼀致,编译器会报警告
为了消除这个警告,我们可以使用强制类型转换:
int a = (int)3.14; //意思是将3.14强制类型转换为int类型,这种强制类型转换只取整数部分
俗话说,强扭的瓜不甜,我们使用强制类型转换都是万不得已的时候使用,如果不需要强制类型转化就能实现代码,这样自然更好。
关系操作符,逻辑操作符和条件操作符在我这篇博客里面有讲到,不会的可以点击链接去学习哟:https://blog.csdn.net/weixin_66058866/article/details/134749600?spm=1001.2014.3001.5501。文章来源:https://www.toymoban.com/news/detail-840508.html
今天先分享到这里,看完别忘了给博主一键三连哟!创作不易,谢谢宝子们❤️!文章来源地址https://www.toymoban.com/news/detail-840508.html
到了这里,关于c语言:操作符详解(上)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!