🎯每日努力一点点,技术进步看得见
🏠专栏介绍:【C语言步行梯】专栏用于介绍C语言相关内容,每篇文章将通过图片+代码片段+网络相关题目的方式编写,欢迎订阅~~
文章目录
算术运算符
我们在算术计算中,无非就是加、减、乘、除。在C语言中,加法使用’+‘(加号),减法使用’-‘(减号),乘法使用’*‘(星号),除法使用’/'(斜杠)。
下面代码演示了加、减、乘、除↓↓↓
#include <stdio.h>
int main()
{
int add = 1 + 2;
int sub = 1 - 2;
int mul = 1 * 2;
double div = 1 / 2;
printf("add = %d\n", add);
printf("sub = %d\n", sub);
printf("mul = %d\n", mul);
printf("div = %lf\n", div);
return 0;
}
上面的程序执行结果中,加减乘都没有错,但1÷2怎么会等于0呢?
C语言中的除法,如果在’/‘两侧都是整型数据,则它的计算结果只保留小数,小数点后面的数字不保留。如果想得到小数点后面的数,则要保证’/'两侧至少有一个是小数(double/float型)。上面的代码改为如下形式即可↓↓↓
#include <stdio.h>
int main()
{
int add = 1 + 2;
int sub = 1 - 2;
int mul = 1 * 2;
double div = 1 / 2.0;
printf("add = %d\n", add);
printf("sub = %d\n", sub);
printf("mul = %d\n", mul);
printf("div = %d\n", div);
return 0;
}
下面再介绍一个算术运算符’%'(取模运算符)。我们在做整除除法时,可能会出现余数。例如:19÷5=3…4,其中4就是余数。取模运算符就是用于计算余数的,因而19%5=4。下面来看一下示例代码↓↓↓
#include <stdio.h>
int main()
{
int mod = 19 % 5;
printf("%d\n", mod);
return 0;
}
★ps:上述运算符中,除了’%‘运算符,其余运算符均可用于整数和浮点数运算。’%‘运算符的两个操作数必须都是整数,它的计算结果是前操作数除后操作数的余数。对于’/‘运算符,如果两侧都是整数,则计算结果只保留整数,不保留小数部分;如果两侧中有一个为浮点数,则计算结果为浮点数。’/‘和’%'的右侧操作数不可以为0。
原码、反码、补码介绍
对于正数原码、反码、补码均相同,都是该正数的二进制表示。我们可以采用模二取余法计算一个数的二进制表示形式。以19为例,19÷2=9…1,9÷2=4…1,4÷2=2…0,2÷2=1…0。一直除到结果为1或0停止。然后从后向前读,得到10011,这就是19的二进制表示。对于正数原码、反码、补码均相同,因而整型的19的原码、反码、补码均为00000000 00000000 00000000 00010011。
对于负数的-19,它的二进制表示计算方法和正数相同,只是要将最左侧的二进制位改为1。最左侧的二进制这里表示为符号位,为0表示正数,为1表示负数。对于负数的原码等于它的二进制表示,即10000000 00000000 00000000 00010011。负数的反码等于它的原码除符号位外,其他位按位取反(0变1,1变0),即11111111 11111111 11111111 11101100。负数的补码等于补码加1,即11111111 11111111 11111111 11101101。
对于负数的原码、反码、补码的相互转化,这里有一组公式(如下图所示):
移位运算符
左移运算符
移位运算符移动的是二进制位,并且是对该数字的补码做移位操作,对于左移运算符的移位规则是:符号位保留不变,除符号位外的左边抛弃,右边补0。以上述19为例,它的二进制表示为00000000 00000000 00000000 00010011;移位后,它最左侧的0抛弃,它的右侧补一个0,即00000000 00000000 00000000 00100110(转化为10进制,结果为38)。
#include <stdio.h>
int main()
{
int num = 19;
int result = num << 1;
printf("%d\n", num); //19
printf("%d\n", result); //38
return 0;
}
★ps:num<<1结果为38,将其赋值给result,但num本身的数值不会发生变化。
再来看一下-19的计算结果。↓↓↓
对该结果取反加1得到原码为10000000 00000000 00000000 00100110,它转变为十进制为38。
#include <stdio.h>
int main()
{
int num = -19;
int result = num << 1;
printf("%d\n", num); //-19
printf("%d\n", result); //-38
return 0;
}
右移运算符
右移运算符的运算规则分为两种:
- 逻辑移位,左侧用0填充,右侧舍弃
- 算术移位,左侧用符号位填充,右侧舍弃。
正数的符号位0,右移的结果不管使用逻辑移位还是算术移位,计算结果均相同。这里使用负数来演示逻辑移位和算术移位,以-19为例。
C语言标准中没有明确规定右移运算使用算术移位还是逻辑移位,一般编译器采用算术移位。下面result结果是-10。
#include <stdio.h>
int main()
{
int num = -19;
int result = num >> 1;
printf("%d\n", num); //-19
printf("%d\n", result); //-10
return 0;
}
★ps:⚠不要移动负数位,因为标准未定义移动负数位的结果,下面的结果是未知的。
int num = 10;
num >> -1;//error
位操作符
位运算符有:‘&’(按位与)、‘|’(按位或)、‘^’(按位异或)。注意:这三个操作符的操作数必须为整数。
对于’&‘(按位与),如果两个二进制位均为1,则该位为1,否则为0;对于’|‘(按位或),如果两个二进制均为0,则该位为0,否则为1;对于’^'(按位异或),如果两个二进制位相同则为0,不同则为1。下图为这三个运算符的举例运算↓↓↓
我们可以做个小练习,看看下面代码的计算结果是什么?
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
printf("%d\n", num1 & num2);
printf("%d\n", num1 | num2);
printf("%d\n", num1 ^ num2);
return 0;
}
结果为:0 3 3,解析如下图所示↓↓↓
下面我们对位操作符和移位运算符做些小训练。
( ఠൠఠ )ノtest1:不能创建临时变量(第三个变量,实现两个数的交换)。
#include <stdio.h>
int main()
{
int num1 = 5;
int num2 = 6;
printf("交换前:num1 = %d, num2 = %d\n", num1, num2);
num1 = num1 ^ num2;
num2 = num1 ^ num2;//注释标记1
num1 = num1 ^ num2;//注释标记2
printf("交换后:num1 = %d, num2 = %d\n", num1, num2);
return 0;
}
在执行到注释标记1时,num1=num1^num2=5^6
,num2=num2=6
。执行num2=num1^num2时
,使用num1=num1^num2
替换该表达式的num1表达式位置,得到num2=(num1^num2)^num2=num1=5
。
★ps:一个数异或上自身,得到的结果为0。一个数与0异或等于它自身。
在执行到注释标记2时,此时num1=num1^num2=5^6
,num2=num1=5
。执行num1=num1^num2时
,使用num1=num1^num2
替换该表达式的num1表达式位置,而此时num2与num1相等,可以使用num1替换num2,得到num1=(num1^num2)^num1=num1=6
。
( ఠൠఠ )ノtest2:编写代码实现:求一个整数存储在内存中的二进制位的1的个数。
方法1:
#include <stdio.h>
int main()
{
int num = 66;
int count = 0;
while(num)
{
if(num % 2 == 1)
count++;
num /= 2;
}
printf("%d\n", count);
return 0;
}
方法2:
#include <stdio.h>
int main()
{
int num = 66;
int count = 0;
for(int i = 0; i < 32; i++)
{
if((num >> i) & 1 == 1)
count++;
}
printf("%d\n", count);
return 0;
}
方法3:
#include <stdio.h>
int main()
{
int num = 66;
int count = 0;
while(num)
{
count++;
num = num & (num - 1);
}
printf("%d\n", count);
return 0;
}
上述3种方法中,第3种方法最难理解,这里对其做解释。再以最初的19为例,它的二进制表示为00000000 00000000 00000000 00010011,当它减1后,则为00000000 00000000 00000000 00010010,与原数字想与后,就可以将最右侧的1抹去。00000000 00000000 00000000 00010010减1变为00000000 00000000 00000000 00010001,与00000000 00000000 00000000 00010010相与后,又可以将最后一个1抹去。以此类推…
赋值操作符
赋值运算符在前面我们已经多次使用到了,也就是’='(等号)。它可以用于初始化的使用进行赋值操作,也可以在中途修改某个变量的值。如下面代码所示↓↓↓
#include <stdio.h>
int main()
{
int a = 10;//初始化赋值
int b = 20;
int c = b + 1;
a = 20;//中途修改
b = c = a;//连续赋值,将a的值赋值给c,再将c赋值给b,最终三个数都为20
return 0;
}
除了孤零零的一个=
,还有符合赋值运算符+=
、-=
、*=
、/=
、%=
、>>=
、<<=
、&=
、|=
、^=
。例如:a+=10
等价于a=a+10
,a-=10
等价于a=a-10
,以此类推。
单目运算符
像加法操作了两个数字,如1+2,所以+号称为双目操作符。而单目操作符的操作数只有一个。如!
(逻辑反操作符)、+
(正值)、-
(负值)、&
(取地址)、sizeof
(计算操作符类型长度,单位为字节)、~
(对一个数的二进制位取反)、--
(对数字减1)、++
(对数字加1)、*
(间接访问操作符/解引用操作符)、(类型名)
(强制类型转换)。下面就对这些操作符挨个做出介绍。
上面我们刚介绍完一个数的二进制表示,如果想把它的每个二进制位取反(0变1,1变0),则可以使用’~'操作符。
#include <stdio.h>
int main()
{
int a = 0;
printf("%d", ~a);//结果为-1
}
数字有正,也有负。如果想要表示一个数是正数,可以在它的前面加’+‘(正号);如果想要表示一个数是负数,可以在它的前面加’-'(符号)。
#include <stdio.h>
int main()
{
int a = +10;
int b = -10;
printf("%d, %d\n",a, b);
return 0;
}
如果我们想要知道一个变量在内存中的保存地址,可以在该变量的前面加上’&';如果想知道该变量所占的内存空间(单位:字节)大小,可以使用sizeof。
★ps:下面代码的注释中给出了大量关于sizeof的说明。
#include <stdio.h>
void test(int arr[])
{
printf("%d\n", sizeof(arr));//注意:数组传递给函数后,arr不再表示真个数组,而是表示指向数组首地址的指针
//指针在32位机器下为4字节,在64位机器下为8字节
}
int main()
{
int arr[10] = {0};
printf("%p\n", &arr[0]);//输出数组首元素地址
printf("%d\n", sizeof(arr));//输出为40,一个int元素占4个字节空间,10个int元素占40字节
test(arr);
int num = 0;
printf("%d\n", sizeof num);//计算一个变量所占字节数,可以省略括号,这也说明了sizeof不是函数,而是操作符
printf("%d\n", sizeof(int));//sizeof后面接类型名称时,括号不可以省略
}
在C语言中,0表示假,非0表示真。如果在0的前面加上’!‘,就表示非0,非0就是真;如果在非0的前面加上’!‘,就表示假。’!'又称为逻辑取反运算符,可以将真变假,将假变真。
#include <stdio.h>
int main()
{
if(!0)
{
printf("haha\n");//这句话将被打印
}
if(!666)
{
printf("I am sad!\n");//这句话不会被打印
}
return 0;
}
在单目运算符的最后,我们来了解一下++
和--
运算符。这两个运算符可以进一步划分为前置++、前置–、后置++和后置–。下面通过一段代码来解释它们的区别。
#include <stdio.h>
void test1()
{
int a = 1;
int b = a++;
int c = ++a;
printf("a = %d, b = %d, c = %d\n", a, b, c);
}
void test2()
{
int a = 1;
int b = a--;
int c = --a;
printf("a = %d, b = %d, c = %d\n", a, b, c);
}
int main()
{
test1();
test2();
return 0;
}
test1打印的结果为3 1 3。b=a++
等价于b=a;a+=1;
,而c=++a
等价于a+=1;c=a;
。前置++和后置++的区别在于:前置++是先给变量自身+1,再使用该值进行赋值或者其他操作,而后置++是先使用该值进行赋值或者其他操作,再给该变量自身+1。
test2打印的结果为-2 1 -2。b=a--
等价于b=a;a-=1;
,而c=--a
等价于a-=1;c=a;
。前置–和后置–的区别在于:前置–是先给变量自身-1,再使用该值进行赋值或者其他操作,而后置–是先使用该值进行赋值或者其他操作,再给该变量自身-1。
关系操作符
生活中的关系莫过于:大于、小于、大于等于、小于等于、不等于、等于。C语言使用如下操作符表示以上关系。
关系 | 操作符 |
---|---|
大于 | > |
小于 | < |
大于等于 | >= |
小于等于 | <= |
等于 | == |
不等于 | != |
这几个操作符大多用于条件判断,下面给出部分操作符的代码示例:
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
if(a > b)
{
printf("a大于b");
}
if(a < b)
{
printf("a小于b");
}
return 0;
}
逻辑操作符
在C语言中有两个逻辑操作符,分别是&&
(并且)和||
(或者)。对于并且来说,只有左右两侧均为真,它的结果才为真;对于或者来说,只有左右两侧均为假,它的结果才为假。
左表达式 | 右表达式 | 或者结果 | 并且结果 |
---|---|---|---|
真 | 真 | 真 | 真 |
真 | 假 | 真 | 假 |
假 | 真 | 真 | 假 |
假 | 假 | 假 | 假 |
对于&&(并且)来说,如果它的左表达式已经为假,则它的值一定为假。因而,在C语言中,如果&&的左表达式为假时,它的右表达式不会执行。同理,对于||(或者)来说,如果它的左表达式为真,则它的值一定为真,因而,在C语言中,如果||的左表达式为真时,它的有表达式不会执行。
根据上面&&和||的特点,咱一起来看一下下面代码的执行结果会是什么?
#include <stdio.h>
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("a = %d, b = %d, c = %d, d = %d\n", a, b, c, d);
return 0;
}
上面代码的执行结果为:a = 1, b = 2, c = 3, d = 4。
在执行i = a++ && ++b && d++;
时,由于a++中为后置++,表达式中a的值先使用,再对a进行加1操作。此时a=0,第一个表达式为假,后序表达式不执行。故b、d的值没有变化。
条件操作符
我们在使用条件判断时常常会使用if…else…语句,如下面代码所示。
#include <stdio.h>
{
int a = 0;
int num1 = 10;
int num2 = 20;
if(num1 > num2)
{
a = num1;
}
else
{
a = num2;
}
printf("%d\n", a);
return 0;
}
上面代码演示了求出两个数中的较大值。为了使代码更加简洁明了,C语言中有了条件操作符——express1?express2:express3
(这个的express1、express2、express3表示的是表达式)。它的用法是:如果表达式1为真,则执行表达式2;如果表达式1为假的执行表达式3。
因而,上面求出两个数中的较大值的代码可精简成下面这样↓↓↓
#include <stdio.h>
int main()
{
int max = 0;
int num1 = 10;
int num2 = 20;
max = (num1 > num2 ? num1 : num2);
return 0;
}
逗号表达式
所谓逗号表达式,就是用逗号隔开的多个表达式。逗号表达式从左向右依次执行,整个表达式的结果是最后一个表达式的结果。
#include <stdio.h>
int main()
{
int a = 5;
int b = 6;
int c = (a > b, a = b + 10, b = a + 1);
}
上面代码中,逗号表达式从左向右执行,依次是a > b
,a = b + 10
(执行完此句后,a=15),b=a+1
(执行完此句后,b=16)。逗号表达式的结果是最后一个表达式的结果,也就是16。这段代码执行完后,a=15,b=16,c=16。
下标引用、函数调用和结构成员
当我们需要访问一个数组的元素时,我们就需要使用到下标引用操作符[]
。
#include <stdio.h>
int main()
{
int arr[5] = {1, 2, 3, 4, 5};
for(int i = 0; i < 5; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
如果我们需要调用一个函数,就需要使用到函数调用操作符()
。它将接收一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数。
#include <stdio.h>
void sayHi()
{
printf("hi\n");
}
void printNum(int num)
{
printf("%d\n", num);
}
int main()
{
sayHi();//调用该函数,函数调用操作符接收了一个参数:函数名sayHi
printNum(1);//调用该函数,函数调用操作符接收了两个参数:函数名printNum、数字1
}
关于结构体将会在后面的文章中再做详细介绍,下面给出粗略介绍。
结构体成员访问操作符分为两种,分别是.
和->
。如果结构体不是指针时,则使用.
访问该结构体成员;如果使用结构体指针变量访问结构体成员时,则需要使用->
。
#include <stdio.h>
struct Stu
{
char name[20];
int age;
}
void printStu(struct Stu* s)
{
printf("%s 's age is %d\n", s->name, s->age);
}
int main()
{
struct Stu s1 = {"Jammingpro", 18};
print(&s1);
printf("%s 's age is %d\n", s.name, s.age);
return 0;
}
类型转换与算术转换
强制类型转换
如果我们需要将一个double类型的变量赋值给int类型,编译器可能会给出警告。因为数字的精度可能会丢失。我们可以使用强制类型转换来避免这种警告,即使用(类型名称)
运算符。
#include <stdio.h>
int main()
{
double num = 6.66;
int result = (int)num;
printf("%d\n", result);
return 0;
}
当然,强制类型转换的作用不仅于此,在其他文章中会陆续展示它的使用方法。
隐式类型转换
C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为整型提升。
整型提升的意义:
表达式的整型运算要在CPU的相应运算器件内执行,CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度,同时也是CPU的通用寄存器的长度。
因此,即使两个char类型的相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长
度。
通用CPU是难以直接实现两个8比特字节直接相加运算(虽然机器指令中可能有这种字节相加指令)。所以,表达式中各种长度可能小于int长度的整型值,都必须先转换为int或unsigned int,然后才能送入CPU去执行运算。
如何进行整型提升
整形提升是按照变量的数据类型的符号位来提升的。对于char类型来说,它占1个字节,即8个比特位。对于char的正负1,下图给出整型提升结果。对于char类型的-1,它的补码为11111111,因为它的符号位为1,在整型提升时,会在它的符号位前填充24个1;对于char类型的1,它的补码为00000001,因为它的符号位为0,在整型提升时,会在它的符号位前填充24个0。
如果对上面的a和b变量执行a+b的操作,则a和b会先进行整型提升,使用整型提升的结果进行相加操作。待相加完成后,会进行截断,保留低8比特的数据,丢弃前24比特。
下面给出一个整型提升的例子↓↓↓
#include <stdio.h>
int main()
{
char ch = 0xb6;
short sh = 0xb600;
int num = 0xb60000;
if(ch == 0xb6)
printf("ch\n");
if(sh == 0xb600)
printf("sh\n");
if(num == 0xb60000)
printf("num\n");
return 0;
}
该程序的执行结果为:num。
程序中的ch和sh均要进行整型提升。两者均变为负数,与原来0xb6、0xb600(再未被赋值前,默认是整型)这些正数显然不相等。因而只有num==0xb60000为真并执行。
再来看一个例子:
#include <stdio.h>
int main()
{
char c = '0';
printf("%u ", sizeof(c));
printf("%u ", sizeof(+c));
printf("%u \n", sizeof(-c));
return 0;
}
该程序的执行结果为1 4 4。因为+c
和-c
在进行运算时会进行整型提升,故它们的大小等于整型的大小。
算术转换
如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类型,否则操作就无法进行。下面的层次体系称为寻常算术转换。
如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运算。
★ps:但是算术转换要合理,要不然会有一些潜在的问题。
float num = 0.66;
int a = num;//会导致精度损失,小数点后面的位数无法保存
表达式求值顺序
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
两个相邻的操作符先执行哪个?取决于他们的优先级。如果两者的优先级相同,取决于他们的结合性。
★ps:我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就是存在问题的。
🚩这篇文章结束了~~
如果文章中出现了错误,欢迎私信或留言。(๑•̀ㅂ•́)و✧
有任何疑问请评论或私信哦~~o( ̄▽ ̄)ブ