🎯每日努力一点点，技术进步看得见
🏠专栏介绍：【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(￣▽￣)ブ
![中间件 | RPC - [Dubbo]](https://img-blog.csdnimg.cn/direct/f2296201d2604c08aea759d34b456e9a.png)
