🎯每日努力一点点，技术进步看得见
🏠专栏介绍：【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);	//19printf("%d\n", result);	//38return 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);	//-19printf("%d\n", result);	//-38return 0;
}

右移运算符

右移运算符的运算规则分为两种：

1. 逻辑移位，左侧用0填充，右侧舍弃
2. 算术移位，左侧用符号位填充，右侧舍弃。

正数的符号位0，右移的结果不管使用逻辑移位还是算术移位，计算结果均相同。这里使用负数来演示逻辑移位和算术移位，以-19为例。

C语言标准中没有明确规定右移运算使用算术移位还是逻辑移位，一般编译器采用算术移位。下面result结果是-10。

#include <stdio.h>int main()
{int num = -19;int result = num >> 1;printf("%d\n", num);	//-19printf("%d\n", result);	//-10return 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;//注释标记1num1 = num1 ^ num2;//注释标记2printf("交换后：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，最终三个数都为20return 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();//调用该函数，函数调用操作符接收了一个参数：函数名sayHiprintNum(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;//会导致精度损失，小数点后面的位数无法保存

表达式求值顺序

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。

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

★ps：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

🚩这篇文章结束了~~
如果文章中出现了错误，欢迎私信或留言。(๑•̀ㅂ•́)و✧
有任何疑问请评论或私信哦~~o(￣▽￣)ブ