目录
深刻理解整形提升
左移和右移规则
如何理解"丢弃"
一个问题
0x01<<2+3 的值是多少
花括号
++、--操作
表达式匹配：贪心算法
深刻理解整形提升
#include <stdio.h>
int main()
{
char c = 0;
printf("sizeof(c): %d\n", sizeof(c)); //1
printf("sizeof(c): %d\n", sizeof(~c)); //4
printf("sizeof(c): %d\n", sizeof(c << 1)); //4
printf("sizeof(c): %d\n", sizeof(c >> 1)); //4
return 0;
}
char类型的c经过按位取反、左移和右移是不是char类型了？为什么char类型的c加了操作符运算求空间大小就不是1了呢？
无论任何位运算符，目标都是要计算机进行计算的，而计算机中只有CPU具有运算能力(先这样简单理解)，但计算的数据， 都在内存中。故，计算之前(无论任何运算),都必须将数据从内存拿到CPU中，拿到CPU哪里呢？毫无疑问，在CPU 寄存器 中。 而寄存器本身，随着计算机位数的不同，寄存器的位数也不同。一般，在32位下，寄存器的位数是32位。 可是，你的char类型数据，只有8比特位。读到寄存器中，只能填补低8位，那么高24位呢？ 就需要进行“整形提升”。
char类型的数据经过按位取反、左移和右移后，仍然是char类型的数据，这些操作不会改变数据的类型。char类型进行操作符运算进行了整形提升，由于寄存器的位数是32位，char类型的变量会提升为int类型，所以求的空间大小就是4个字节。
对于vs编译器(图右)上将!c所占空间定为1个字节，我们可以认为这是编译器的bug，因为c参加了运算，必定会进行整形提升，在gcc编译器(图左)下我们就可以发现!c所占空间是4个字节。
左移和右移规则
#include <stdio.h>
int main()
{
/*
<<(左移): 最高位丢弃，最低位补零
>>(右移)：
1. 无符号数：最低位丢弃,最高位补零 [逻辑右移]
2. 有符号数：最低位丢弃，最高位补符号位 [算术右移]
*/
//左移
unsigned int a = 1; //0000 0000 0000 0000 0000 0000 0000 0001 - 1
printf("%u\n", a << 1);//0000 0000 0000 0000 0000 0000 0000 0010 - 2
printf("%u\n", a << 2);//0000 0000 0000 0000 0000 0000 0000 0100 - 4
printf("%u\n", a << 3);//0000 0000 0000 0000 0000 0000 0000 1000 - 8
//逻辑右移
unsigned int b = 100; //0000 0000 0000 0000 0000 0000 0110 0100 - 100
printf("%u\n", b >> 1);//0000 0000 0000 0000 0000 0000 0011 0010 - 50
printf("%u\n", b >> 2);//0000 0000 0000 0000 0000 0000 0001 1001 - 25
printf("%u\n", b >> 3);//0000 0000 0000 0000 0000 0000 0000 1100 - 12
//算术右移，最高位补符号位1， 虽然移出了最低位1，但是补得还是1
int c = -1; //1111 1111 1111 1111 1111 1111 1111 1111 - -1
printf("%d\n", c >> 1);//1111 1111 1111 1111 1111 1111 1111 1111 - -1
printf("%d\n", c >> 2);//1111 1111 1111 1111 1111 1111 1111 1111 - -1
printf("%d\n", c >> 3);//1111 1111 1111 1111 1111 1111 1111 1111 - -1
//是算术右移，还是逻辑右移?最高位补0，为何？
unsigned int d = -1; //1111 1111 1111 1111 1111 1111 1111 1111
printf("%d\n", d >> 1);//0111 1111 1111 1111 1111 1111 1111 1111 - 2147483647
printf("%d\n", d >> 2);//0011 1111 1111 1111 1111 1111 1111 1111 - 1073741823
printf("%d\n", d >> 3);//0001 1111 1111 1111 1111 1111 1111 1111 - 536870911
return 0;
}结论：
左移，无脑补0。
右移，先判定是算术右移还是逻辑右移，判定依据：看自身类型，和变量的内容无关。
判定了是算术，还是逻辑，才能决定最高位补什么。
如何理解"丢弃"
'<<' 和 '>>' 都是计算，都要在CPU中进行，可是参与移动的变量，是在内存中的。 所以需要先把数据移动到CPU内寄存器中，在进行移动。 那么，在实际移动的过程中，是在寄存器中进行的，即大小固定的单位内。那么，左移右移一定会有位置跑到"外边"的情况。
一个问题
#include<stdio.h>
int main()
{
int a = 10;
a << 1; //有没有影响a本身的值，为什么？怎么样做能影响a的值
printf("%d\n", a);
return 0;
}
0x01<<2+3 的值是多少
#include <stdio.h>
int main()
{
//0x01：0000 0000 0000 0000 0000 0000 0000 0001
printf("%d\n", 0x01 << 2 + 3);//32
printf("%d\n", 0x01 << (2 + 3));//32
printf("%d\n", (0x01 << 2) + 3);//7
return 0;
}这是一个C语言程序，其中定义了一个main函数，函数中执行了三个printf语句，分别输出了三个表达式的结果。
这三个表达式的意义如下：
1. 0x01 << 2 + 3
这个表达式中，先进行加法运算2+3，结果为5，然后再对0x01（二进制为0000 0001）进行左移5位操作，即在二进制的右侧补5个0，得到的结果为0010 0000，即十进制的32。
2. 0x01 << (2 + 3)
这个表达式中，由于加法运算的优先级比位运算低，所以先执行括号内的加法运算，得到的结果为5。然后再对0x01进行左移5位操作，得到的结果为0010 0000，即十进制的32。
3. (0x01 << 2) + 3
这个表达式中，先对0x01进行左移2位操作，得到的结果为0000 0100，即十进制的4。然后再将得到的结果与3进行加法运算，得到的结果为7。
综上所述，这个程序的输出结果为：32 32 7
花括号
在C语言中，花括号是用来表示代码块的。一个代码块包含一组语句，可以作为一个整体进行控制。花括号通常用于控制语句（如if、for、while等）的语法结构，以及函数、结构体等作用域的定义中。 在代码中，花括号用于将一组语句组合成一个代码块。花括号中的语句可以被认为是一个整体，可以作为一个单元进行控制。
//别这么写
#include <stdio.h>
int main()
{
char a[] = { "abcde" };
printf("%d\n", sizeof(a));
char a[]{ = "abcde"};//error
printf("%d\n", sizeof(a));
char a[10]{ = "abcde" };//error
printf("%d\n", sizeof(a));
return 0;
}规规矩矩写代码，不能乱写{ }。
++、--操作
#include <stdio.h>
int main()
{
int a = 10;
int b = ++a; //前置++， 先自增在使用
printf("%d, %d\n", a, b); //11,11
return 0;
}程序中的操作主要集中在语句 int b = ++a; 中，这是一个前置++的运算，它的作用是先让a自增1，然后再将自增后的值赋给b，因此，最终a和b的值都变成了11。
#include <stdio.h>
int main()
{
int a = 10;
int b = a++; //后置++， 先使用在自增
printf("%d, %d\n", a, b); //11, 10
return 0;
}程序中的操作主要集中在语句 int b = a++; 中，它是一个后置++运算，它的作用是先将a的值赋给b，然后再执行自增操作，因此，最终a的值为11，而b的值为10。
#include <stdio.h>
int main()
{
int a = 0xDD;
//有b接收，那么a的先使用是将a的值(内容),放到b中
int b = a++;
int c = 0xEE;
//没有接收方，那么"先使用"，如何理解？
c++;
return 0;
}
a++完整的含义是先使用，在自增。如果没有变量接收，那么直接自增(或者所谓使用，就是读取进寄存器，然后没有 然后)。
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0;
}
本代码结果不同的原因就是 i 变量自增后有没有影响后面的 i 值。i 是自己自增完后经过加法运算后 i 再自增，还是三次 i 都自增完然后再进行加法操作。
我们现在来看一下vs下的计算过程
本质：是因为上面表达式的"计算路径不唯一"(为什么?编译器识别表达式，是同时加载至寄存器，还是分批加载，完全不确定)导致的。以后，类似这种复杂表达式，我们一律不推荐使用或者编写。
表达式匹配：贪心算法
#include<stdio.h>
int main()
{
int a = 10;
int b = 20;
printf("%d\n", a++++ + b); //自动匹配失败
// 贪心算法:(a++)++ + b
int a = 10;
int b = 20;
printf("%d\n", a++ + ++b); //自行分离匹配，非常不推荐，不过能看出空格的好处
return 0;
}在这段代码中，我们看到了两个不同的表达式。第一个表达式是 `a++++ + b`，它会自动匹配失败，因为自增运算符只能和一个变量一起使用。由于自增运算符的优先级比加法运算符高，因此编译器会将其解释为 `(a++)++ + b`，这是非法的表达式。因此，编译器会报告错误。
第二个表达式是 `a++ + ++b`，它虽然能够被编译器解析正确，但这种写法不够清晰，不推荐使用。这个表达式中包含了两个自增运算符，其中一个跟在变量名前面，另一个跟在变量名后面。由于自增运算符的优先级高于加法运算符，编译器会首先对 `++b` 进行自增操作，然后将 `a` 和 `b` 进行加法运算。文章来源：https://www.toymoban.com/news/detail-450882.html
在这两个表达式中，我们都可以看到贪心算法的影子。贪心算法会尽可能地选择当前最优的解决方案，但在这里，由于自增运算符只能和一个变量一起使用，所以编译器只能尽量匹配，直到遇到无法匹配的表达式为止。因此，为了避免这种情况，我们应该尽量避免写出复杂的、不清晰的表达式。文章来源地址https://www.toymoban.com/news/detail-450882.html
到了这里，关于learn_C_deep_11 (深刻理解整形提升、左移和右移规则、花括号、++和--操作、表达式匹配：贪心算法)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
