C语言操作符 - 技术栈

1.二进制

c 复制代码

15的2进制:1111
15的8进制:17
15的10进制:15
15的16进制:F

10进制满10进1
10进制的数字每一位都是0-9的数字组成
2进制满2进1
2进制的数字每一位都是0-1的数字组成

1.1 2进制转10进制

10进制的每一位是有权重的，10进制的数字从右向左是个位，十位，百位... ，分别每一位的权重是10^0,10^1,10^2...

2进制的每一位权重，从右向左是2^0,2^1,2^3...

1.1.1 10进制转2进制数字

1.2 2进制转8进制和16进制

1.2.1 2进制转8进制

8进制的数字每一位是0-7的，0-7的数字，各自写成2进制，最多有3个2进制位就足够了，比如7的二进制是111，所以在2进制转8进制数的时候，从2进制序列中最右边开始向左每三个2进制位会换算一个8进制位，剩余不够3个2进制位的直接换算

如:2进制的01101011，换成8进制:0153，0开头的数字，会被当成8进制

1.2.2 2进制转16进制

16进制的数字每一位是0-9，a-f的数字，各自写成2进制，最多有4个2进制位就足够了，比如f的二进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算一个16进制位，剩余不够4个的二进制位的直接换算

2.原码，反码，补码

整数的2进制表示方法有三种，即原码，反码，补码

三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当做符号位的，剩余的都是数值位

符号位都是用0表示＂正＂，用1表示＂负＂

正整数的原，反，补码都相同
负整数的三种表示方法各不相同
原码 :直接将数值按照正负数的形式翻译成二进制得到的就是原码
反码 :将原码的符号位不变，其他位依次按位取反可以得到饭反码
补码:反码+1就得到补码

对于整型来说:数据存放内存中其实存放的是补码

在计算机系统中，数值一律用补码来表示和存储，原因在于，使用补码，可以将符号位和数值位统一处理，同时，加法和减法也可以统一处理(cpu只有加法器)，此外，补码和原码相互转换，其运算过程是相同的，不需要额外的硬件电路

3.移位操作符

"<<"左移操作符

">>"右移操作符

注:移位操作符的操作数只能是整数

3.1左移操作符

移位规则:左边抛弃，右边补0

c 复制代码

#include <stdio.h>
int main()
{
 int num = 10;
 int n = num<<1;
 printf("n= %d\n", n);
 printf("num= %d\n", num);
 return 0;
}

3.2右移操作符

移位规则:右移运算分两种

1.逻辑右移:左边用0填充，右边丢弃

2.算术右移:左边用原该值的符号位填充，右边丢弃

c 复制代码

#include <stdio.h>
int main()
{
 int num = 10;
 int n = num>>1;
 printf("n= %d\n", n);
 printf("num= %d\n", num);
 return 0;
}

注:对于移位操作符，不要移动负数位，这个是标准为定义的

4.位操作符:&，｜，^，~

c 复制代码

& //按位与
| //按位或
^ //按位异或
~ //按位取反
注：他们的操作数必须是整数。

使用

c 复制代码

#include <stdio.h>
int main()
{
 int num1 = -3;
 int num2 = 5;
 num1 & num2;
 num1 | num2;
 num1 ^ num2;
 return 0;
}

不能创建临时变量(第三个变量)，实现两个数时交换

c 复制代码

#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的个数

c 复制代码

//⽅法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++)
 {
 f( 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

编写代码将13二进制序列的第5位修改为1，然后再改回0

c 复制代码

13的2进制序列： 00000000000000000000000000001101
将第5位置为1后：00000000000000000000000000011101
将第5位再置为0：00000000000000000000000000001101

c 复制代码

#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;
}

5. 逗号表达式

c 复制代码

exp1, exp2, exp3, ...expN

逗号表达式，就是用逗号隔开的多个表达式

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果

c 复制代码

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//代码2
if (a =b + 1, c=a / 2, d > 0)
//代码3
a = get_val();
count_val(a);
while (a > 0)
{
 a = get_val();
 count_val(a);
}
如果使⽤逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{

}

6.下标访问[]，函数调用()

6.1[]下标引用操作符

操作数:一个数组名+一个索引值

c 复制代码

int arr[10];//创建数组
arr[9] = 10;//实⽤下标引⽤操作符。
[ ]的两个操作数是arr和9。

6.2函数调用操作符

接受一个或多个操作数:第一个操作数是函数名，剩余的操作数就是传递给函数的参数

c 复制代码

#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;
}

7.操作符的属性:优先级，结合性

C语言的操作符有2个重要的属性:优先级，结合性，这两个属性决定了表达式求值的计算顺序

7.1优先级

优先级指的是，如果一个表达式包含多个运算符，哪个运算符应该优先执行，各种运算符的优先级是不同的

c 复制代码

3 + 4 * 5;

上面示例中，表达式里面既有加法运算符(+)，又有乘法运算符()，由于乘法的优先级高于加法，所以会先计算45

7.2结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个的时候，就要看结合性，根据运算符是左结合还是右结合，决定执行顺序，大部分运算符是左结合(从左向右执行，少数运算符是右结合(从右到左执行)，比如赋值运算符(＝)

c 复制代码

5 * 6 / 2;

上面示例中，和/的优先级相同，都是左结合运算符，从左到右执行，先计算56

运算符优先级顺序很多，下面是部分运算符的优先级顺序(按照优先级从高到低)

圆括号（ () ）
⾃增运算符（ ++ ），⾃减运算符（ -- ）
单⽬运算符（ + 和 - ）
乘法（ * ），除法（ / ）
加法（ + ），减法（ - ）
关系运算符（ < 、 > 等）
赋值运算符（ = ）
注:由于圆括号的优先级最高，可以使用它改变其他运算符的优先级

参考网站：https://zh.cppreference.com/w/c/language/operator_precedence

8.表达式求值

8.1整型提升

C语言中整型算数运算是至少以缺省整型的精度来进行的

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升

整型提升的意义:

表达式的整型运算要在相应运算器件内执行，cpu内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是cpu的通用寄存器的长度因此，即使两个char类型的相加，在cpu执行时实际上也要先转换为cpu内整型操作数的标准长度
通用cpu是难以直接实现两个8比特位字节直接相加运算(虽然机器指令中可能没有这种字节相加的指令)，所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsighned int，然后才能送入cpu去执行运算

c 复制代码

//实例1
char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算，加法运算完成后，结果被截断，然后再存储于a中

如何进行整型提升?

1.有符号整数提升是按照变量的数据类型的符号位来提升的
2.无符号中整数提升，高位补0

c 复制代码

/负数的整形提升
char c1 = -1;
变量c1的⼆进制位(补码)中只有8个⽐特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
/正数的整形提升
char c2 = 1;
变量c2的⼆进制位(补码)中只有8个⽐特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//⽆符号整形提升，⾼位补0

8.2算数转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作无法进行，下面的层次体系称为寻常算数转换

c 复制代码

long double
double
float
unsigned long int
long int
unsigned int
int

如果某个操作数的类型在上面这个列表中排名靠后，那么首先要转换为另一个操作数的类型后执行运算

8.3问题表达式

8.3.1表达式1

c 复制代码

a*b + c*d + e*f

表达式1在计算的时候，由于*比+的优先级高，只能保证，的运算是比+早，但是优先级并不能决定第三个 比第一个+早执行，所以顺序可能是

代码

8.3.2表达式2

c 复制代码

c + --c;

操作符的优先级只能决定自减--运算在+的运算的前面，但没办法得知，+操作符的左操作数的获取在右操作数之前还是之后的值，所以结果不可预测

8.3.3表达式3

c 复制代码

int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}

表达式3在不同的编译器中测试结果

8.3.4表达式4

c 复制代码

#include <sdtio.h>
int fun()
{
 static int count = 1;
 return ++count;
}
int main()
{
 int answer;
 answer = fun() - fun() * fun();
 printf( "%d\n", answer);
 return 0;
}

上述代码只能知道先算乘法再算减法，函数的调用顺序无法通过优先级确定

8.3.5表达式5

c 复制代码

#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}

这段代码的第一个+执行的时候，第三个+是否执行不确定

即使有了操作符的优先级和结合性，我们写出出的表达式也不一定通过操作符的属性确定唯一计算路径，这个表达式就存在一定潜在风险