深刻理解整形提升
#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` 进行加法运算。
在这两个表达式中，我们都可以看到贪心算法的影子。贪心算法会尽可能地选择当前最优的解决方案，但在这里，由于自增运算符只能和一个变量一起使用，所以编译器只能尽量匹配，直到遇到无法匹配的表达式为止。因此，为了避免这种情况，我们应该尽量避免写出复杂的、不清晰的表达式。
