根据变量中存储的值的不同，我们可以将变量分为两类：
普通变量：变量所对应的内存中存储的是普通值。指针变量：变量所对应的内存中存储的是另一个变量的地址。如下图所示：
NOTE
普通变量和指针变量的相同点：
普通变量和指针变量的不同点：
NOTE
普通变量中存储的值的类型不同，可以将普通变量类型划分为基本数据类型（整型、字符类型、浮点类型、布尔类型）和复合数据类型（数组类型、结构体类型、共用体类型、枚举类型）。指针变量所指向空间中存储的值的类型不同，可以将指针类型分为基本数据类型指针、复合数据类型指针、函数指针、数组指针等，例如：如果指针所指向的空间保存的是 int 类型，那么该指针就是 int 类型的指针。内存空间大小的不同，可以将整数类型划分为：| 类型 | 存储空间（内存空间） | 取值范围 |
|---|---|---|
| unsigned short （无符号短整型） | 2 字节 | 0 ~ 65,535 (2^16 - 1) |
| [signed] short（有符号短整型，默认） | 2 字节 | -32,768 (- 2^15) ~ 32,767 (2^15 -1) |
| 类型 | 存储空间（内存空间） | 取值范围 |
|---|---|---|
| unsigned int（无符号整型） | 4 字节（通常） | 0 ~ 4294967295 (0 ~2^32 -1) |
| [signed] int（有符号整型，默认） | 4 字节（通常） | -2147483648（- 2^31） ~ 2147483647 (2^31-1) |
| 类型 | 存储空间（内存空间） | 取值范围 |
|---|---|---|
| unsigned long（无符号长整型） | 4 字节（通常） | 0 ~2^32 -1 |
| [signed] long（有符号长整型，默认） | 4 字节（通常） | - 2^31 ~ 2^31-1 |
| 类型 | 存储空间（内存空间） | 取值范围 |
|---|---|---|
| unsigned long long（无符号长整型） | 8 字节（通常） | 0 ~2^64 -1 |
| [signed] long long（有符号长整型，默认） | 8 字节（通常） | - 2^63 ~ 2^63-1 |
IMPORTANT
① 数据类型在内存中占用的存储单元（字节数），就称为该数据类型的长度（步长），如：short 占用 2 个字节的内存，就称 short 的长度（步长）是 2。
② C 语言并没有严格规定各种整数数据类型在内存中所占存储单元的长度，只做了宽泛的限制：
③ 那么，各种整数数据类型在内存中所占存储单元的长度的公式就是 2 ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long)，具体的存储空间由编译系统自行决定。其中，sizeof 是测量类型或变量、常量长度的运算符。
IMPORTANT
最常用的整数类型就是 int 类型了，如果取值范围不够，就使用 long 或 long long 。格式占位符非常多，只需要大致了解即可；因为，我们在实际开发中，一般都会使用 C++ 或 Rust 以及其它的高级编程语言，如：Java 等，早已经解决了必须通过格式占位符来才能将变量进行输入和输出。unsigned short x = 10 ; // 无符号短整型short x = -10; // 有符号短整型NOTE
printf 中无符号短整型（unsigned short）的格式占位符是 %hu ，有符号短整型（signed short）的格式占位符是 %hd 。sizeof 运算符获取无符号短整型（unsigned short） 和 有符号短整型（signed short） 的存储空间（所占内存空间）。#include <limits.h> 来获取 无符号短整型（unsigned short） 和有符号短整型（signed short）的取值范围。#include <stdio.h>
int main() {
// 定义有符号 short 类型
signed short s1 = -100;
printf("s1 = %hd \\n", s1); // s1 = -100
// 定义无符号 short 类型
unsigned short s2 = 100;
printf("s2 = %hu \\n", s2); // s2 = 100
// 定义 short 类型，默认是有符号
short s3 = -200;
printf("s3 = %hd \\n", s3); // s3 = -200
return 0;
}#include <stdio.h>
int main() {
size_t s1 = sizeof(unsigned short);
printf("unsigned short 的存储空间是 %zu 字节 \\n", s1); // 2
size_t s2 = sizeof(signed short);
printf("signed short 的存储空间是 %zu 字节 \\n", s2); // 2
size_t s3 = sizeof(short);
printf("short 的存储空间是 %zu 字节 \\n", s3); // 2
return 0;
}#include <limits.h>
#include <stdio.h>
int main() {
printf("unsigned short 类型的范围是[0,%hu]\\n", USHRT_MAX); // [0,65535]
printf("short 类型的范围是[%hd,%hd]\\n", SHRT_MIN,SHRT_MAX); // [-32768,32767]
return 0;
}unsigned int x = 10 ; // 无符号整型int x = -10; // 有符号整型NOTE
printf 中无符号整型（unsigned int）的格式占位符是 %u ，有符号整型（signed int）的格式占位符是 %d 。sizeof 运算符获取无符号整型（unsigned int） 和 有符号整型（signed int） 的存储空间（所占内存空间）。#include <limits.h> 来获取 无符号整型（unsigned int） 和有符号整型（signed int）的取值范围。#include <stdio.h>
int main() {
// 定义有符号 int 类型
signed int i1 = -100;
printf("i1 = %d \\n", i1); // i1 = -100
// 定义无符号 int 类型
unsigned int i2 = 100;
printf("i2 = %u \\n", i2); // i2 = 100
// 定义 int 类型，默认是有符号
short i3 = -200;
printf("i3 = %d \\n", i3); // i3 = -200
return 0;
}#include <stdio.h>
int main() {
size_t i1 = sizeof(unsigned int);
printf("unsigned int 的存储空间是 %zu 字节 \\n", i1); // 4
size_t i2 = sizeof(signed int);
printf("signed int 的存储空间是 %zu 字节 \\n", i2); // 4
size_t i3 = sizeof(int);
printf("int 的存储空间是 %zu 字节 \\n", i3); // 4
return 0;
}#include <limits.h>
#include <stdio.h>
int main() {
printf("unsigned int 类型的范围是[0,%u]\\n", UINT_MAX); // [0,4294967295]
printf("int 类型的范围是[%d,%d]\\n", INT_MIN,INT_MAX); // [-2147483648,2147483647]
return 0;
}unsigned long x = 10 ; // 无符号长整型long x = -10; // 有符号长整型NOTE
printf 中无符号长整型（unsigned long）的格式占位符是 %lu ，有符号长整型（signed long）的格式占位符是 %ld 。sizeof 运算符获取无符号长整型（unsigned long） 和 有符号长整型（signed long） 的存储空间（所占内存空间）。#include <limits.h> 来获取 无符号长整型（unsigned long） 和有符号长整型（signed long）的取值范围。#include <stdio.h>
int main() {
// 定义有符号 long 类型
signed long l1 = -100;
printf("l1 = %ld \\n", l1); // l1 = -100
// 定义无符号 long 类型
unsigned long l2 = 100;
printf("l2 = %lu \\n", l2); // l2 = 100
// 定义 long 类型，默认是有符号
long l3 = -200;
printf("l3 = %ld \\n", l3); // l3 = -200
return 0;
}#include <stdio.h>
int main() {
size_t l1 = sizeof(unsigned long);
printf("unsigned long 的存储空间是 %zu 字节 \\n", l1); // 4
size_t l2 = sizeof(signed long);
printf("signed long 的存储空间是 %zu 字节 \\n", l2); // 4
size_t l3 = sizeof(long);
printf("long 的存储空间是 %zu 字节 \\n", l3); // 4
return 0;
}#include <limits.h>
#include <stdio.h>
int main() {
printf("unsigned long 类型的范围是[0,%lu]\\n", ULONG_MAX); // [0,4294967295]
printf("long 类型的范围是[%ld,%ld]\\n", LONG_MIN,LONG_MAX); // [-2147483648,2147483647]
return 0;
}unsigned long long x = 10 ; // 无符号长长整型long long x = -10; // 有符号长长整型NOTE
printf 中无符号长长整型（unsigned long long）的格式占位符是 %llu ，有符号长长整型（signed long long）的格式占位符是 %lld 。sizeof 运算符获取无符号长长整型（unsigned long long） 和 有符号长长整型（signed long long） 的存储空间（所占内存空间）。#include <limits.h> 来获取 无符号长长整型（unsigned long long） 和有符号长长整型（signed long long）的取值范围。#include <stdio.h>
int main() {
// 定义有符号 long long 类型
signed long long ll1 = -100;
printf("ll1 = %lld \\n", ll1); // ll1 = -100
// 定义无符号 long long 类型
unsigned long long ll2 = 100;
printf("ll2 = %llu \\n", ll2); // ll2 = 100
// 定义 long long 类型，默认是有符号
long long ll3 = -200;
printf("ll3 = %lld \\n", ll3); // ll3 = -200
return 0;
}#include <stdio.h>
int main() {
size_t ll1 = sizeof(unsigned long long);
printf("unsigned long long 的存储空间是 %zu 字节 \\n", ll1); // 8
size_t ll2 = sizeof(signed long long);
printf("signed long long 的存储空间是 %zu 字节 \\n", ll2); // 8
size_t ll3 = sizeof(long long);
printf("long long 的存储空间是 %zu 字节 \\n", ll3); // 8
return 0;
}#include <limits.h>
#include <stdio.h>
int main() {
printf("unsigned long long 类型的范围是[0,%llu]\\n", ULLONG_MAX); // [0,18446744073709551615]
printf("long long 类型的范围是[%lld,%lld]\\n", LLONG_MIN,LLONG_MAX); // [-9223372036854775808,9223372036854775807]
return 0;
}字面量是源代码中一个固定值的表示方法，用于直接表示数据，即：int num1 = 100; // 100 就是字面量long num2 = 100L; // 100L 就是字面量long long num3 = 100LL; // 100LL 就是字面量NOTE
long 类型的字面量，需要添加后缀 l 或 L ，建议 L。long long 类型的字面量，需要添加后缀 ll 或 LL，建议 LL 。无符号整数类型的字面量，需要添加 u 或 U，建议 U 。#include <stdio.h>
int main() {
int num = 100;
printf("num = %d\\n", num); // num = 100
long num2 = 100L;
printf("num2 = %ld\\n", num2); // num2 = 100
long long num3 = 100LL;
printf("num3 = %lld\\n", num3); // num3 = 100
unsigned int num4 = 100U;
printf("num4 = %u\\n", num4); // num4 = 100
unsigned long num5 = 100LU;
printf("num5 = %lu\\n", num5); // num5 = 100
unsigned long long num6 = 100ULL;
printf("num6 = %llu\\n", num6); // num6 = 100
return 0;
}NOTE
<stdint.h> 中定义了一些新的类型别名，如下所示：| 类型名称 | 含义 |
|---|---|
| int8_t | 8 位有符号整数 |
| int16_t | 16 位有符号整数 |
| int32_t | 32 位有符号整数 |
| int64_t | 64 位有符号整数 |
| uint8_t | 8 位无符号整数 |
| uint16_t | 16 位无符号整数 |
| uint32_t | 32 位无符号整数 |
| uint64_t | 64 位无符号整数 |
NOTE
上面的这些类型都是类型别名，编译器会指定它们指向的底层类型，如：在某个系统中，如果 int 类型是 32 位，那么 int32_t 就会指向 int ；如果 long 类型是 32 位，那么 int32_t 就会指向 long。
#include <stdio.h>
#include <stdint.h>
int main() {
// 变量 x32 声明为 int32_t 类型，可以保证是 32 位(4个字节)的宽度。
int32_t x32 = 45933945;
printf("x32 = %d \\n", x32); // x32 = 45933945
return 0;
}sizeof(表达式)NOTE
① sizeof 是运算符，不是内置函数。
② 表达式可以是任何类型的数据类型、变量或常量。
③ 用来获取某种数据类型、变量或常量占用的字节数量（内存中的存储单元），并且 sizeof(...) 的返回值类型是 size_t ；并且，如果是变量名称，可以省略 ()；如果是数据类型，则不能省略 ()。
④ 在 printf 中使用占位符 %zu 来处理 size_t 类型的值。
⑤ 之前，也提过，C 语言没有一个统一的官方机构来制定或强制执行其标准，而是由一个标准委员会负责制定标准。不同的编译器可以选择部分或完全遵循这些标准。因此，C 语言的编译器实现可能会有所不同，这就要求程序员在编写跨平台代码时特别注意数据类型的大小和布局。
⑥ 与 C 语言不同，Java 和 JavaScript 等语言的标准是强制性的。在 Java 语言中，int 类型在所有平台上都是 4 个字节，无论是在 Linux、MacOS 还是 Windows 上。因此，这些语言不需要像 C 语言那样依赖 sizeof 来处理不同平台上的数据类型大小差异，因为编译器已经在底层处理了这些差异。换言之，sizeof 运算符在 C 语言中的重要性在于它为程序员提供了一个处理不同平台上数据类型大小差异的工具。当然，如果你在 C 语言中，使用精确宽度类型，如：int8_t、int16_t、int32_t、uint8_t、 uint16_t、uint32_t 等，也可以确保代码在各个平台上的一致性。
#include <stdio.h>
#include <stddef.h>
int main() {
size_t s = sizeof(int);
printf("%zu \\n", s); // 4
return 0;
}#include <stdio.h>
#include <stddef.h>
int main() {
int num = 10;
size_t s = sizeof(num);
printf("%zu \\n", s); // 4
return 0;
}#include <stdio.h>
#include <stddef.h>
int main() {
size_t s = sizeof(10);
printf("%zu \\n", s); // 4
return 0;
}溢出（overflow）。NOTE
最大值，再进行加法计算，数据就会超过该类型能够表示的最大值，叫做上溢出（如果最大值 + 1 会“绕回”到最小值）。最小值，再进行减法计算，数据就会超过该类型能够表示的最小值， 叫做下溢出（如果最小值 - 1 会“绕回”到最大值）。IMPORTANT
无符号数（unsigned 类型）的取值范围（最大值和最小值）的计算是很容易的，即：将内存中的所有位，设置为 0 就是最小值，设置为 1 就是最大值。IMPORTANT
在 C 语言中，无符号整数，最高位不是符号位，它是数值的一部分。
unsigned char 类型为例，它在内存中占用的存储单元是 1 个字节，即 8 位。如果所有位都设置为 0 ，它的最小值就是 0 ；如果所有位设置为 1 ，它的最大值就是 2⁸ - 1 = 255 ，如下所示：unsigned char 的最大值是如何计算出来的？最简单的方法就是这样的，如下所示： 1 × 2⁰ + 1 × 2¹ + 1 × 2² + 1 × 2³ + 1 × 2⁴ + 1 × 2⁵ + 1 × 2⁶ + 1 × 2⁷
= 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128
= 255 1111 1111 + 1 - 1
= 10000 0000 - 1
= 2⁹⁻¹ - 1
= 2⁸ - 1
= 255IMPORTANT
unsinged char（1 个字节） 的取值范围是：[0, 2⁸ - 1]。unsinged short（2 个字节）的取值范围是：[0, 2¹⁶ - 1]。unsinged int（4 个字节）的取值范围是：[0, 2³² - 1]。unsinged long（8 个字节）的取值范围是：[0, 2⁶⁴ - 1]。有符号数（signed 类型）在计算机底层是以补码的形式存储的（计算的时候，也是以补码的形式进行计算的，并且符号位参与计算）；但是，在读取的时候，需要采用逆向的转换，即：将补码转换为原码。IMPORTANT
在 C 语言中，有符号整数，最高位是符号位，用于表示正负数。
char 类型为例，它的取值范围，如下所示：| 补码 | 反码 | 原码 | 值 |
|---|---|---|---|
| 1111 1111 | 1111 1110 | 1000 0001 | -1 |
| 1111 1110 | 1111 1101 | 1000 0010 | -2 |
| 1111 1101 | 1111 1100 | 1000 0011 | -3 |
| ... | ... | ... | ... |
| 1000 0011 | 1000 0010 | 1111 1101 | -125 |
| 1000 0010 | 1000 0001 | 1111 1110 | -126 |
| 1000 0001 | 1000 0000 | 1111 1111 | -127 |
| 1000 0000 | --- | --- | -128 |
| 0111 1111 | 0111 1111 | 0111 1111 | 127 |
| 0111 1110 | 0111 1110 | 0111 1110 | 126 |
| 0111 1101 | 0111 1101 | 0111 1101 | 125 |
| ... | ... | ... | ... |
| 0000 0010 | 0000 0010 | 0000 0010 | 2 |
| 0000 0001 | 0000 0001 | 0000 0001 | 1 |
| 0000 0000 | 0000 0000 | 0000 0000 | 0 |
char 类型的取值范围是：[-2⁸, 2⁸ - 1]，即：[-128, 127]。-128 而言，它的补码是 1000 0000，是无法按照传统的补码表示法来计算原码的，因为在补码转换到反码的时候需要 -1 ，而 1000 0000 - 1需要向高位借 1 ，而最高位是符号位是不能借的，这就非常矛盾。IMPORTANT
计算机规定，1000 0000 这个特殊的补码就表示 -128 。
-128 ，而不是其它数字？是因为 -128 使得 char 类型的取值范围保持连贯，中间没有“空隙”。如果我们按照传统的方式来计算 -128 的补码，如下所示： 1000 0000，但是 char 的数据位只有 7 位，那么最高位 1 就变为了符号位，剩下的数据位就是 000 0000；所以，-128 的原码就是 1000 0000。1111 1111 。+1，得到 1000 0000，是因为符号位被覆盖了，补码最终依然是 1000 0000。NOTE
-128 从原码转换到补码的过程中，符号位被 1 覆盖了两次，而负数的符号位本来就是 1，被 1 覆盖多少次也不会影响到数字的符号。
1000 0000 这个补码推算不出 -128，但是从 -128 却能推算出 1000 0000 这个补码，即：有符号数在存储之前先要转换为补码。IMPORTANT
-128 就成为了补码的最小值 1000 0000，而这个值不会与其他任何正数或负数的补码冲突。 原码存储，那么将会出现 +0 和 -0 的情况，即：0000 0000、1000 0000，这样在取值范围内，就存在两个相同的值，多此一举。原码存储，最大值不变是 127 ，但是最小值只能存储到 -127 ，不能存储到 -128，因为 -128 的原码是 1000 0000，和 -0 的原码冲突。char（1 个字节） 的取值范围是：[-2⁸, 2⁸ - 1]。short（2 个字节）的取值范围是：[-2¹⁶, 2¹⁶ - 1]。int（4 个字节）的取值范围是：[-2³², 2³² - 1]。long（8 个字节）的取值范围是：[-2⁶⁴, 2⁶⁴ - 1]。无符号的数值溢出： +1 就会回到无符号数的最小值。-1 就会回到无符号数的最大值。IMPORTANT
2^n - 1 。如果某个计算结果超出了这个范围，计算机会自动将结果对 2^N 取余（模），从而丢失高位，只保留低位。8 位无符号整数而言，最大值是 255（1111 1111）；那么， 255 + 1 的结果就是 (2^8 -1 + 1) % 2^8 = 0，商是 256。8 位无符号整数而言，最小值是 0（0000 0000），那么， 0 - 1 的结果就是 (0 - 1) % 2^8 = 255，商是 -1。无符号的上溢出，原理就是这样的：无符号的下溢出，原理就是这样的：对于有符号的数值溢出：
+1 就会回到有符号数的最小值。-1 就会回到有符号数的最大值。那么，有符号的上溢出，原理就是这样的：
有符号的下溢出，原理就是这样的：#include <limits.h>
#include <stdio.h>
int main() {
unsigned short s1 = USHRT_MAX + 1;
printf("无符号的上溢出 = %hu \\n", s1); // 0
unsigned short s2 = 0 - 1;
printf("无符号的下溢出 = %hu \\n", s2); // 65535
return 0;
}#include <limits.h>
#include <stdio.h>
int main() {
short s1 = SHRT_MAX + 1;
printf("有符号的上溢出 = %hd \\n", s1); // -32768
short s2 = SHRT_MIN - 1;
printf("有符号的下溢出 = %hd \\n", s2); // 32767
return 0;
}整数，如：18、25 之外，还会使用到小数，如：3.1415926、6.18 等，小数在计算机中也被称为浮点数（和底层存储有关）。整数在计算机底层的存储被称为定点存储，如下所示：小数在计算机底层的存储被称为浮点存储，如下所示：NOTE
| 类型 | 存储大小 | 值的范围 | 有效小数位数 |
|---|---|---|---|
| float（单精度） | 4 字节 | 1.2E-38 ~ 3.4E+38 | 6 ~ 9 |
| double（双精度） | 8 字节 | 2.3E-308 ~ 1.7E+308 | 15 ~ 18 |
| long double（长双精度） | 16 字节 | 3.4E-4932 ~ 1.2E+4932 | 18 或更多 |
NOTE
double 类型；如果范围不够，就使用 long double 类型。float 类型的格式占位符，是 %f ，默认会保留 6 位小数，不足 6 位以 0 补充；可以指定小数位，如：%.2f 表示保留 2 位小数。double 类型的格式占位符，是 %lf ，默认会保留 6 位小数，不足 6 位以 0 补充；可以指定小数位，如：%.2lf 表示保留 2 位小数。long double 类型的格式占位符，是 %Lf ，默认会保留 6 位小数，不足 6 位以 0 补充；可以指定小数位，如：%.2Lf 表示保留 2 位小数。NOTE
科学计数法形式的 float 类型的浮点数，则使用 %e。科学计数法形式的 double 类型的浮点数，则使用 %le。科学计数法形式的 long double 类型的浮点数，则使用 %Le。NOTE
%g（g 是 general format 的缩写，即：通用格式），%g 会根据数值的大小自动判断，选择使用普通的浮点数格式（%f）进行输出，还是使用科学计数法（%e）进行输出，即：float 类型的两种输出形式。%lg 会根据数值的大小自动判断，选择使用普通的浮点数格式（%lf）进行输出，还是使用科学计数法（%le）进行输出，即：double 类型的两种输出形式。%Lg 会根据数值的大小自动判断，选择使用普通的浮点数格式（%Lf）进行输出，还是使用科学计数法（%Le）进行输出，即：long double 类型的两种输出形式。#include <stdio.h>
int main() {
float f1 = 10.0;
printf("f1 = %f \\n", f1); // f1 = 10.000000
printf("f1 = %.2f \\n", f1); // f1 = 10.00
return 0;
}#include <stdio.h>
int main() {
double d1 = 13.14159265354;
printf("d1 = %lf \\n", d1); // d1 = 13.141593
printf("d1 = %.2lf \\n", d1); // d1 = 13.14
return 0;
}#include <stdio.h>
int main() {
long double d1 = 13.14159265354;
printf("d1 = %LF \\n", d1); // d1 = 13.141593
printf("d1 = %.2LF \\n", d1); // d1 = 13.14
return 0;
}#include <stdio.h>
int main() {
float f1 = 3.1415926;
double d2 = 3.14e2;
printf("f1 = %.2f \\n", f1); // f1 = 3.14
printf("f1 = %.2e \\n", f1); // f1 = 3.14e+00
printf("d2 = %.2lf \\n", d2); // d2 = 314.00
printf("d2 = %.2e \\n", d2); // d2 = 3.14e+02
return 0;
}浮点数字面量默认是 double 类型。
如果需要表示 float 类型的字面量，需要后面添加后缀 f 或 F，建议 F。
如果需要表示 long double 类型的字面量，需要后面添加后缀 l 或 L，建议 L。
示例：
#include <stdio.h>
int main() {
float f1 = 3.1415926f;
double d2 = 3.1415926;
long double d3 = 3.1415926L;
printf("f1 = %.2f \\n", f1); // f1 = 3.14
printf("d2 = %.3lf \\n", d2); // d2 = 3.142
printf("d3 = %.4Lf \\n", d3); // d3 = 3.1416
return 0;
}可以通过 sizeof 运算符来获取 float、double 以及 long double 类型占用的内存大小（存储空间）。
示例：
#include <stdio.h>
int main() {
printf("float 的存储空间是 %zu 字节 \\n", sizeof(float)); // 4
printf("double 的存储空间是 %zu 字节 \\n", sizeof(double)); // 8
printf("long double 的存储空间是 %zu 字节 \\n", sizeof(long double)); // 16
return 0;
}可以通过 #include <float.h> 来获取类型的取值范围。
示例：
#include <float.h>
#include <stdio.h>
int main() {
printf("float 的取值范围是：[%.38f, %f] \\n", FLT_MIN, FLT_MAX);
printf("double 的取值范围是：[%lf, %lf] \\n", DBL_MIN, DBL_MAX);
printf("double 的取值范围是：[%Lf, %Lf] \\n", LDBL_MIN, LDBL_MAX);
return 0;
}WARNING
#include <stdio.h>
int main() {
// 禁用 stdout 缓冲区
setbuf(stdout, NULL);
float a = 123; // 整数赋值给浮点类型，只需要在小数点，后面加 0 即可
printf("a=%f \\n", a); // a=123.000000
int b = 123.00; // 浮点赋值给整数类型，会直接截断小数点后面的数
printf("b=%d \\n", b); // b=123
return 0;
}好，我的性别是 女，我今年 10 岁等。像这类数据，在 C 语言中就可以用字符类型（char）来表示。字符类型表示单个字符，使用单引号（''）括起来，如：'1'、'A'、'&'。你是好人，只是现阶段，我想学习、好的啊，我们在一起等。像这类数据，在 C 语言中就可以用字符串（String）来表示。字符串类型表示多个字符的集合，使用双引号（""）括起来，如："1"、"A"、"&"、"我们"。NOTE
转义字符 \\来表示特殊含义的字符。| 转义字符 | 说明 |
|---|---|
\\b | 退格 |
\\n | 换行符 |
\\r | 回车符 |
\\t | 制表符 |
\\" | 双引号 |
\\' | 单引号 |
\\\\ | 反斜杠 |
| ... |
在 C 语言中，使用 %c 来表示 char 类型。
示例：
#include <stdio.h>
int main() {
char c = '&';
printf("c = %c \\n", c); // c = &
char c2 = 'a';
printf("c2 = %c \\n", c2); // c2 = a
char c3 = 'A';
printf("c3 = %c \\n", c3); // c3 = A
return 0;
}可以通过 sizeof 运算符来获取 char 类型占用的内存大小（存储空间）。
示例：
#include <stdio.h>
int main() {
printf("char 的存储空间是 %d 字节\\n", sizeof(char)); // 1
printf("unsigned char 的存储空间是 %d 字节\\n", sizeof(unsigned char)); // 1
return 0;
}可以通过 #include <limits.h> 来获取类型的取值范围。
示例：
#include <limits.h>
#include <stdio.h>
int main() {
printf("char 范围是[%d,%d] \\n", CHAR_MIN,CHAR_MAX); // [-128,127]
printf("unsigned char 范围是[0,%d]\\n", UCHAR_MAX); // [0,255]
return 0;
}字符类型的数据在计算机中存储和读取的过程，如下所示：#include <limits.h>
#include <stdio.h>
int main() {
// char 类型字面量需要使用单引号包裹
char a1 = 'A';
char a2 = '9';
char a3 = '\\t';
printf("c1=%c, c3=%c, c2=%c \\n", a1, a3, a2);
// char 类型本质上整数可以进行运算
char b1 = 'b';
char b2 = 101;
printf("%c->%d \\n", b1, b1);
printf("%c->%d \\n", b2, b2);
printf("%c+%c=%d \\n", b1, b2, b1 + b2);
// char 类型取值范围
unsigned char c1 = 200; // 无符号 char 取值范围 0 ~255
signed char c2 = 200; // 有符号 char 取值范围 -128~127，c2会超出范围
char c3 = 200; // 当前系统，char 默认是 signed char
printf("c1=%d, c2=%d, c3=%d", c1, c2, c3);
return 0;
}printf() 函数输出字符之外，还可以使用 putchar()函数输出字符。NOTE
putchar() 函数每次只能输出一个字符，如果需要输出多个字符需要调用多次；而 printf() 函数一次可以输出多个字符，并且 char 类型对应的格式占位符是 %c。printf() 函数居多。#include <stdio.h>
int main() {
char a = '1';
char b = '2';
char c = '&';
/* 12& */
putchar(a);
putchar(b);
putchar(c);
return 0;
}字符数组来模拟字符串的，即：可以使用字符数组来存储字符串。NOTE
数组和指针通常会一起出现，所以当字符数组可以保存字符串，也就意味着可以使用指针来间接存储字符串。puts() 函数输出字符串，每调用一次 puts() 函数，除了输出字符串之外，还会在字符串后面加上换行，即：\\n 。printf() 函数输出字符串，并且字符串对应的格式占位符是 %s。和 puts() 函数不同的是，printf() 函数不会在字符串后面加上换行，即：\\n。printf() 函数居多。#include <stdio.h>
int main() {
// 存储字符串
char str[] = "我";
char *str2 = "爱你";
puts(str); // 我
puts(str2); // 爱你
return 0;
}#include <stdio.h>
int main() {
// 存储字符串
char str[] = "你";
char *str2 = "是好人";
printf("%s\\n", str); // 你
printf("%s\\n", str2); // 是好人
return 0;
}在 C 语言标准（C89）中，并没有为布尔值单独设置一个数据类型，所以在判断真、假的时候，使用 0 表示 false（假），非 0 表示 true（真）。
示例：
#include <stdio.h>
int main() {
// 禁用 stdout 缓冲区
setbuf(stdout, NULL);
// 使用整型来表示真和假两种状态
int handsome = 0;
printf("帅不帅[0 丑，1 帅]： ");
scanf("%d", &handsome);
if (handsome) {
printf("你真的很帅！！！");
} else {
printf("你真的很丑！！！");
}
return 0;
}判断真假的时候，以 0 为 false（假）、1 为 true（真），并不直观；所以，我们可以借助 C 语言的宏定义。
示例：
#include <stdio.h>
// 宏定义
#define BOOL int
#define TRUE 1
#define FALSE 0
int main() {
// 禁用 stdout 缓冲区
setbuf(stdout, NULL);
BOOL handsome = 0;
printf("帅不帅[FALSE 丑，TRUE 帅]： ");
scanf("%d", &handsome);
if (handsome) {
printf("你真的很帅！！！");
} else {
printf("你真的很丑！！！");
}
return 0;
}在 C99 中提供了 _Bool 关键字，用于表示布尔类型；其实，_Bool类型的值是整数类型的别名，和一般整型不同的是，_Bool类型的值只能赋值为 0 或 1 （0 表示假、1 表示真），其它非 0 的值都会被存储为 1 。
示例：
#include <stdio.h>
int main() {
// 禁用 stdout 缓冲区
setbuf(stdout, NULL);
int temp; // 使用 int 类型的变量临时存储输入
_Bool handsome = 0;
printf("帅不帅[0 丑，1 帅]： ");
scanf("%d", &temp);
// 将输入值转换为 _Bool 类型
handsome = (temp != 0);
if (handsome) {
printf("你真的很帅！！！");
} else {
printf("你真的很丑！！！");
}
return 0;
}<stdbool.h>，定义了 bool 代表 _Bool，false 代表 0 ，true 代表 1 。NOTE
在 C++、Java 等高级编程语言中是有 boolean 类型的关键字的。
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
int main() {
// 禁用 stdout 缓冲区
setbuf(stdout, NULL);
char input[10];
bool handsome = false;
printf("帅不帅[false 丑，true 帅]： ");
scanf("%s", input); // 使用 %s 读取字符串
// 将输入字符串转换为布尔值
if (strcmp(input, "true") == 0) {
handsome = true;
} else if (strcmp(input, "false") == 0) {
handsome = false;
} else {
printf("无效输入！\\n");
return 1;
}
if (handsome) {
printf("你真的很帅！！！");
} else {
printf("你真的很丑！！！");
}
return 0;
}窄类型会自动转换为宽类型，这样就不会造成精度损失。WARNING
最好避免无符号整数与有符号整数的混合运算，因为这时 C 语言会自动将 signed int 转为 unsigned int ，可能不会得到预期的结果。
#include <stdio.h>
/**
* 不同的整数类型混合运算时，宽度较小的类型会提升为宽度较大的类型。
* 比如 short 转为 int ，int 转为 long 等。
*/
int main() {
short s1 = 10;
int i = 20;
// s1 是 short 类型，i 是 int 类型。
// 当 s1 和 i 运算的时候，会自动转为 int 类型后，然后再计算。
int result = s1 + i;
printf("result = %d \\n", result);
return 0;
}#include <stdio.h>
int main() {
int n2 = -100;
unsigned int n3 = 20;
// n2 是有符号，n3 是无符号。
// 当 n2 和 n3 运算的时候，会自动转为无符号类型后，然后再计算。
int result = n2 + n3;
printf("result = %d \\n", result);
return 0;
}#include <stdio.h>
/**
* 不同的浮点数类型混合运算时，宽度较小的类型转为宽度较大的类型。
* 比如 float 转为 double ，double 转为 long double 。
*/
int main() {
float f1 = 1.25f;
double d2 = 4.58667435;
// f1 是 float 类型，d2 是 double 类型。
// 当 f1 和 d2 运算的时候，会自动转为 double 类型后，然后再计算。
double result = f1 + d2;
printf("result = %.8lf \\n", result);
return 0;
}#include <stdio.h>
/**
* 整型与浮点型运算，整型转为浮点型
*/
int main() {
int n4 = 10;
double d3 = 1.67;
// n4 是 int 类型，d3 是 double 类型。
// 当 n4 和 d3 运算的时候，会自动转为 double 类型后，然后再计算。
double result = n4 + d3;
printf("%.2lf", result);
return 0;
}WARNING
C 语言在检查类型匹配方面不太严格，最好不要养成这样的习惯。
#include <stdio.h>
int main() {
// 赋值：窄类型赋值给宽类型
int a1 = 10;
double a2 = a1;
printf("a2: %.2f\\n", a2); // a2: 10.00
// 转换：将宽类型转换为窄类型
double b1 = 10.5;
int b2 = b1;
printf("b2: %d\\n", b2); // b2: 10
return 0;
}数据类型 变量名 = (类型名)变量、常量或表达式;WARNING
强制类型转换可能会导致精度损失！！！
#include <stdio.h>
int main(){
double d1 = 1.934;
double d2 = 4.2;
int num1 = (int)d1 + (int)d2; // d1 转为 1，d2 转为 4，结果是 5
int num2 = (int)(d1 + d2); // d1+d2 = 6.134，6.134 转为 6
int num3 = (int)(3.5 * 10 + 6 * 1.5); // 35.0 + 9.0 = 44.0 -> int = 44
printf("num1=%d \\n", num1);
printf("num2=%d \\n", num2);
printf("num3=%d \\n", num3);
return 0;
}通过之前的知识，我们知道，CPU 是直接和内存打交道的，CPU 在处理数据的时候，会将数据临时存放到内存中。内存那么大，CPU 是怎么找到对应的数据的？
首先，CPU 会将内存按照字节（1 Bytes = 8 bit，我们也称为存储单元）进行划分，如下所示：
NOTE
NOTE
之所以，要给每个存储单元加上内存地址，就是为了加快数据的存取速度，可以类比生活中的字典以及快递单号。
int num = 10;NOTE
上述的代码其实透露了三个重要的信息：
NOTE
IMPORTANT
表达式指的是一组运算数、运算符的组合，表达式一定具有值，一个变量或一个常量可以是表达式，变量、常量和运算符也可以组成表达式，如：操作数指的是参与运算的值或者对象，如：操作数的个数，可以将运算符分为： 功能，可以将运算符分为： NOTE
掌握一个运算符，需要关注以下几个方面：
| 运算符 | 描述 | 操作数个数 | 组成的表达式的值 | 副作用 |
|---|---|---|---|---|
+ | 正号 | 1 | 操作数本身 | ❎ |
- | 负号 | 1 | 操作数符号取反 | ❎ |
+ | 加号 | 2 | 两个操作数之和 | ❎ |
- | 减号 | 2 | 两个操作数之差 | ❎ |
* | 乘号 | 2 | 两个操作数之积 | ❎ |
/ | 除号 | 2 | 两个操作数之商 | ❎ |
% | 取模（取余） | 2 | 两个操作数相除的余数 | ❎ |
++ | 自增 | 1 | 操作数自增前或自增后的值 | ✅ |
-- | 自减 | 1 | 操作数自减前或自减后的值 | ✅ |
NOTE
自增和自减：
变量前++：变量先自增 1 ，然后再运算；变量后++：变量先运算，然后再自增 1 。变量前--：变量先自减 1 ，然后再运算；变量后--：变量先运算，然后再自减 1 。i++ 或 i-- ，各种编程语言的用法和支持是不同的，例如：C/C++、Java 等完全支持，Python 压根一点都不支持，Go 语言虽然支持 i++ 或 i-- ，却只支持这些操作符作为独立的语句，并且不能嵌入在其它的表达式中。#include <stdio.h>
int main() {
int x = 12;
int x1 = -x, x2 = +x;
int y = -67;
int y1 = -y, y2 = +y;
printf("x1=%d, x2=%d \\n", x1, x2); // x1=-12, x2=12
printf("y1=%d, y2=%d \\n", y1, y2); // y1=67, y2=-67
return 0;
}#include <stdio.h>
int main() {
int a = 5;
int b = 2;
printf("%d + %d = %d\\n", a, b, a + b); // 5 + 2 = 7
printf("%d - %d = %d\\n", a, b, a - b); // 5 - 2 = 3
printf("%d × %d = %d\\n", a, b, a * b); // 5 × 2 = 10
printf("%d / %d = %d\\n", a, b, a / b); // 5 / 2 = 2
printf("%d %% %d = %d\\n", a, b, a % b); // 5 % 2 = 1
return 0;
}#include <stdio.h>
int main() {
int res1 = 10 % 3;
printf("10 %% 3 = %d\\n", res1); // 10 % 3 = 1
int res2 = -10 % 3;
printf("-10 %% 3 = %d\\n", res2); // -10 % 3 = -1
int res3 = 10 % -3;
printf("10 %% -3 = %d\\n", res3); // 10 % -3 = 1
int res4 = -10 % -3;
printf("-10 %% -3 = %d\\n", res4); // -10 % -3 = -1
return 0;
}#include <stdio.h>
int main() {
int i1 = 10, i2 = 20;
int i = i1++;
printf("i = %d\\n", i); // i = 10
printf("i1 = %d\\n", i1); // i1 = 11
i = ++i1;
printf("i = %d\\n", i); // i = 12
printf("i1 = %d\\n", i1); // i1 = 12
i = i2--;
printf("i = %d\\n", i); // i = 20
printf("i2 = %d\\n", i2); // i2 = 19
i = --i2;
printf("i = %d\\n", i); // i = 18
printf("i2 = %d\\n", i2); // i2 = 18
return 0;#include <stdio.h>
/*
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
int main() {
int num = 153;
int bai = num / 100;
int shi = num % 100 / 10;
int ge = num % 10;
printf("百位为：%d \\n", bai);
printf("十位为：%d \\n", shi);
printf("个位为：%d \\n", ge);
return 0;
}| 运算符 | 描述 | 操作数个数 | 组成的表达式的值 | 副作用 |
|---|---|---|---|---|
== | 相等 | 2 | 0 或 1 | ❎ |
!= | 不相等 | 2 | 0 或 1 | ❎ |
< | 小于 | 2 | 0 或 1 | ❎ |
> | 大于 | 2 | 0 或 1 | ❎ |
<= | 小于等于 | 2 | 0 或 1 | ❎ |
>= | 大于等于 | 2 | 0 或 1 | ❎ |
NOTE
== 写成 =，== 是比较运算符，而 = 是赋值运算符。>= 或 <=含义是只需要满足 大于或等于、小于或等于其中一个条件，结果就返回真。#include <stdio.h>
int main() {
int a = 8;
int b = 7;
printf("a > b 的结果是：%d \\n", a > b); // a > b 的结果是：1
printf("a >= b 的结果是：%d \\n", a >= b); // a >= b 的结果是：1
printf("a < b 的结果是：%d \\n", a < b); // a < b 的结果是：0
printf("a <= b 的结果是：%d \\n", a <= b); // a <= b 的结果是：0
printf("a == b 的结果是：%d \\n", a == b); // a == b 的结果是：0
printf("a != b 的结果是：%d \\n", a != b); // a != b 的结果是：1
return 0;
}| 运算符 | 描述 | 操作数个数 | 组成的表达式的值 | 副作用 |
|---|---|---|---|---|
&& | 逻辑与 | 2 | 0 或 1 | ❎ |
|| | 逻辑或 | 2 | 0 或 1 | ❎ |
! | 逻辑非 | 2 | 0 或 1 | ❎ |
| a | b | a && b | a || b | !a |
|---|---|---|---|---|
| 1（真） | 1（真） | 1（真） | 1（真） | 0（假） |
| 1（真） | 0（假） | 0（假） | 1（真） | 0（假） |
| 0（假） | 1（真） | 0（假） | 1（真） | 1（真） |
| 0（假） | 0（假） | 0（假） | 0（假） | 1（真） |
NOTE
非零值都表示真，零值表示假，如：5 || 0 返回 1 ，5 && 0 返回 0 。&& 的理解就是：两边条件，同时满足。||的理解就是：两边条件，二选一。! 的理解就是：条件取反。a && b 操作来说，当 a 为假(或 0 )时，因为 a && b 结果必定为 0，所以不再执行表达式 b。a || b 操作来说，当 a 为真(或非 0 )时，因为 a || b 结果必定为 1，所以不再执行表达式 b。#include <stdio.h>
int main() {
int a = 0;
int b = 0;
printf("请输入整数a的值：");
scanf("%d", &a);
printf("请输入整数b的值：");
scanf("%d", &b);
if (a > b) {
printf("%d > %d", a, b);
} else if (a < b) {
printf("%d < %d", a, b);
} else {
printf("%d = %d", a, b);
}
return 0;
}#include <stdio.h>
// 短路现象
int main() {
int i = 0;
int j = 10;
if (i && j++ > 0) {
printf("床前明月光\\n"); // 这行代码不会执行
} else {
printf("我叫郭德纲\\n");
}
printf("%d \\n", j); //10
return 0;
}#include <stdio.h>
// 短路现象
int main() {
int i = 1;
int j = 10;
if (i || j++ > 0) {
printf("床前明月光 \\n");
} else {
printf("我叫郭德纲 \\n"); // 这行代码不会被执行
}
printf("%d\\n", j); //10
return 0;
}| 运算符 | 描述 | 操作数个数 | 组成的表达式的值 | 副作用 |
|---|---|---|---|---|
== | 赋值 | 2 | 左边操作数的值 | ✅ |
+= | 相加赋值 | 2 | 左边操作数的值 | ✅ |
-= | 相减赋值 | 2 | 左边操作数的值 | ✅ |
*= | 相乘赋值 | 2 | 左边操作数的值 | ✅ |
/= | 相除赋值 | 2 | 左边操作数的值 | ✅ |
%= | 取余赋值 | 2 | 左边操作数的值 | ✅ |
<<= | 左移赋值 | 2 | 左边操作数的值 | ✅ |
>>= | 右移赋值 | 2 | 左边操作数的值 | ✅ |
&= | 按位与赋值 | 2 | 左边操作数的值 | ✅ |
^= | 按位异或赋值 | 2 | 左边操作数的值 | ✅ |
|= | 按位或赋值 | 2 | 左边操作数的值 | ✅ |
NOTE
#include <stdio.h>
int main() {
int a = 3;
a += 3; // a = a + 3
printf("a = %d\\n", a); // a = 6
int b = 3;
b -= 3; // b = b - 3
printf("b = %d\\n", b); // b = 0
int c = 3;
c *= 3; // c = c * 3
printf("c = %d\\n", c); // c = 9
int d = 3;
d /= 3; // d = d / 3
printf("d = %d\\n", d); // d = 1
int e = 3;
e %= 3; // e = e % 3
printf("e = %d\\n", e); // e = 0
return 0;
}| 运算符 | 描述 | 操作数个数 | 运算规则 | 副作用 |
|---|---|---|---|---|
& | 按位与 | 2 | 两个二进制位都为 1 ，结果为 1 ，否则为 0 。 | ❎ |
| | 按位或 | 2 | 两个二进制位只要有一个为 1（包含两个都为 1 的情况），结果为 1 ，否则为 0 。 | ❎ |
^ | 按位异或 | 2 | 两个二进制位一个为 0 ，一个为 1 ，结果为 1，否则为 0 。 | ❎ |
~ | 按位取反 | 2 | 将每一个二进制位变成相反值，即 0 变成 1 ， 1 变 成 0 。 | ❎ |
<< | 二进制左移 | 2 | 将一个数的各二进制位全部左移指定的位数，左 边的二进制位丢弃，右边补 0。 | ❎ |
>> | 二进制右移 | 2 | 将一个数的各二进制位全部右移指定的位数，正数左补 0，负数左补 1，右边丢弃。 | ❎ |
NOTE
操作数在进行位运算的时候，以它的补码形式计算！！！
在 C 语言中，printf 是没有提供输出二进制位的格式占位符的；但是，我们可以手动实现，以方便后期操作。
示例：
#include <stdio.h>
/**
* 获取指定整数的二进制表示
* @param num 整数
* @return 二进制表示的字符串，不包括前导的 '0b' 字符
*/
char* getBinary(int num) {
static char binaryString[33];
int i, j;
for (i = sizeof(num) * 8 - 1, j = 0; i >= 0; i--, j++) {
const int bit = (num >> i) & 1;
binaryString[j] = bit + '0';
}
binaryString[j] = '\\0';
return binaryString;
}
int main() {
int a = 17;
int b = -12;
printf("整数 %d 的二进制表示：%s \\n", a, getBinary(a));
printf("整数 %d 的二进制表示：%s \\n", b, getBinary(b));
return 0;
}按位与 & 的运算规则是：如果二进制对应的位上都是 1 才是 1 ，否则为 0 ，即：
1 & 1 的结果是 1 。1 & 0 的结果是 0 。0 & 1 的结果是 0 。0 & 0 的结果是 0 。示例：9 & 7 = 1
-9 & 7 = 7按位与 | 的运算规则是：如果二进制对应的位上只要有 1 就是 1 ，否则为 0 ，即：
1 | 1 的结果是 1 。1 | 0 的结果是 1 。0 | 1 的结果是 1 。0 | 0 的结果是 0 。示例：9 | 7 = 15
-9 | 7 = -9^ 的运算规则是：如果二进制对应的位上一个为 1 一个为 0 就为 1 ，否则为 0 ，即： 1 ^ 1 的结果是 0 。1 ^ 0 的结果是 1 。0 ^ 1 的结果是 1 。0 ^ 0 的结果是 0 。NOTE
按位异或的场景有：
9 ^ 7 = 14-9 ^ 7 = -16运算规则：如果二进制对应的位上是 1，则结果为 0；如果是 0 ，则结果为 1 。
~0 的结果是 1 。~1 的结果是 0 。示例：~9 = -10
~-9 = 8在一定范围内，数据每向左移动一位，相当于原数据 × 2。（正数、负数都适用）
示例：3 << 4 = 48 （3 × 2^4）
-3 << 4 = -48 （-3 × 2 ^4）NOTE
69 >> 4 = 4 （69 ÷ 2^4 ）-69 >> 4 = -5 （-69 ÷ 2^4 ）条件表达式 ? 表达式1 : 表达式2 ;NOTE
#include <stdio.h>
int main() {
int m = 110;
int n = 20;
int result = m > n ? m : n;
printf("result = %d\\n", result); // result = 110
return 0;
}| 优先级 | 运算符 | 名称或含义 | 结合方向 |
|---|---|---|---|
| 1 | [] | 数组下标 | ➡️（从左到右） |
() | 圆括号 | ||
. | 成员选择（对象） | ||
-> | 成员选择（指针） | ||
| 2 | - | 负号运算符 | ⬅️（从右到左） |
（类型） | 强制类型转换 | ||
++ | 自增运算符 | ||
-- | 自减运算符 | ||
* | 取值运算符 | ||
& | 取地址运算符 | ||
! | 逻辑非运算符 | ||
~ | 按位取反运算符 | ||
sizeof | 长度运算符 | ||
| 3 | / | 除 | ➡️（从左到右） |
* | 乘 | ||
% | 余数（取模） | ||
| 4 | + | 加 | ➡️（从左到右） |
- | 减 | ||
| 5 | << | 左移 | ➡️（从左到右） |
>> | 右移 | ||
| 6 | > | 大于 | ➡️（从左到右） |
>= | 大于等于 | ||
< | 小于 | ||
<= | 小于等于 | ||
| 7 | == | 等于 | ➡️（从左到右） |
!= | 不等于 | ||
| 8 | & | 按位与 | ➡️（从左到右） |
| 9 | ^ | 按位异或 | ➡️（从左到右） |
| 10 | | | 按位或 | ➡️（从左到右） |
| 11 | && | 逻辑与 | ➡️（从左到右） |
| 12 | || | 逻辑或 | ➡️（从左到右） |
| 13 | ?: | 条件运算符 | ⬅️（从右到左） |
| 14 | = | 赋值运算符 | ⬅️（从右到左） |
/= | 除后赋值 | ||
*= | 乘后赋值 | ||
%= | 取模后赋值 | ||
+= | 加后赋值 | ||
-= | 减后赋值 | ||
<<= | 左移后赋值 | ||
>>= | 右移后赋值 | ||
&= | 按位与后赋值 | ||
^= | 按位异或后赋值 | ||
|= | 按位或后赋值 | ||
| 15 | , | 逗号运算符 | ➡️（从左到右） |
WARNING
使用小括号来控制表达式的执行顺序。分成几步来完成。唯一的编号（通常是数字）。字符可以是字母、数字、符号、控制代码（如换行符）等。字符集定义了可以表示的字符的范围，但它并不直接定义如何将这些字符存储在计算机中。NOTE
ASCII（美国信息交换标准代码）是最早期和最简单的字符集之一，它只包括了英文字母、数字和一些特殊字符，共 128 个字符。每个字符都分配给了一个从 0 到 127 的数字。
它定义了如何将字符集中的字符转换为计算机存储和传输的数据（通常是一串二进制数字）。简而言之，编码是字符到二进制数据之间的映射规则。NOTE
ASCII 编码方案定义了如何将 ASCII 字符集中的每个字符表示为 7 位的二进制数字。例如：大写字母'A'在 ASCII 编码中表示为二进制的1000001，十进制的 65 。
字符集和字符集编码之间的关系如下：冯·诺依曼体系结构中，我们知道，计算机中所有的数据和指令都是以二进制的形式表示的；所以，计算机中对于文本数据的数据也是以二进制来存储的，那么对应的流程如下：NOTE
a-zA-Z0-9以及一些特殊字符一共 128 就可以满足实际存储需求；所以，在也是为什么 ASCII 码使用 7 位二进制（2^7 = 128 ）来存储的。man asciiè、德语中的 ü 等。NOTE
在 Unicode 之前，世界上存在着数百种不同的编码系统，每一种编码系统都是为了支持特定语言或一组语言的字符集。这些编码系统，包括：ASCII、ISO 8859 系列、GBK、Shift-JIS、EUC-KR 等，它们各自有不同的字符范围和编码方式。这种多样性虽然在局部范围内解决了字符表示的问题，但也带来了以下几个方面的挑战：
编码冲突：由于不同的编码系统可以为相同的字节值分配不同的字符，因此在不同编码之间转换文本时，如果没有正确处理编码信息，就很容易产生乱码。这种编码冲突在尝试处理多种语言的文本时尤为突出。编码的复杂性：随着全球化的发展，软件和系统需要支持越来越多的语言，这就要求开发者和系统同时处理多种不同的编码系统。这不仅增加了开发和维护的复杂性，而且也增加了出错的风险。资源限制：在早期计算机技术中，内存和存储资源相对有限。不同的编码标准要求系统存储多套字符集数据，这无疑增加了对有限资源的消耗。针对上述的种种问题，为了推行全球化，Unicode 应运而生，Unicode 的核心规则和设计原则是建立一个全球统一的字符集，使得世界上所有的文字和符号都能被唯一地识别和使用，无论使用者位于何地或使用何种语言。这套规则包括了字符的编码、表示、处理和转换机制，旨在确保不同系统和软件间能够无缝交换和处理文本数据。
通用字符集 (UCS)：Unicode 为每一个字符分配一个唯一的编号（称为“码点”）。这些码点被组织在一个统一的字符集中，官方称之为 “通用字符集”（Universal Character Set，UCS）。码点通常表示为 U+ 后跟一个十六进制数，例如：U+0041 代表大写的英文字母 “A”。编码平面和区段：Unicode 码点被划分为多个 “平面（Planes）”，每个平面包含 65536（16^4）个码点。目前，Unicode定义了 17 个平面（从 0 到16），每个平面被分配了一个编号，从 “基本多文种平面（BMP）” 的 0 开始，到 16 号平面结束。这意味着 Unicode 理论上可以支持超过 110万（17*65536）个码点。Unicode 仅仅只是字符集，给每个字符设置了唯一的数字编号而已，却没有给出这些数字编号实际如何存储，可以通过如下命令查看：
NOTE
IMPORTANT
UTF-16 编码，主要原因是为了在兼顾字符处理效率的同时，能够有效处理多种语言的字符集，即：历史遗留问题、兼容性要求和多语言支持的需要。UTF-8 编码，主要是为了兼容性和灵活性，因为 UTF-8 编码可以无缝处理 ASCII 字符，同时也能够支持多字节的 Unicode 字符，即：为了最大限度地兼容 ASCII，同时保持系统的简单性、灵活性和效率。Unicode 字符集和对应的UTF-8 字符编码之间的关系，如下所示：NOTE
宽字符和窄字符是编程和计算机系统中对字符类型的一种分类，主要用于描述字符在内存中的表示形式及其与编码方式的关系。
窄字符通常指使用单个字节（8 位）来表示的字符。在许多传统的编码系统中，窄字符通常代表 ASCII 字符或其它单字节字符集中的字符。换言之，窄字符适合处理简单的单字节字符集，如：ASCII，适用于处理西方语言的应用。宽字符指使用多个字节（通常是两个或更多）来表示的字符。这些字符通常用于表示比 ASCII 范围更广的字符集，如 Unicode 字符。换言之，宽字符适合处理多字节字符集，如：UTF-32、UTF-16 等，适用于需要处理多种语言和符号的国际化应用。在现代编程中，窄字符通常与 UTF-8 编码关联，特别是在处理文本输入、输出和网络传输时。尽管 UTF-8 是变长编码，由于其高效的空间利用和对 ASCII 的优化，通常与窄字符概念关联。而宽字符通常与 UTF-16 编码或 UTF-32编码关联，这些编码使用更大的固定或半固定长度来表示字符，适合处理更大的字符集。
echo $LANGNOTE
C.UTF-8 是一种字符编码设置，结合了 C 区域设定和 UTF-8 字符编码。
C 区域设定下，所有字符都被认为是 ASCII 字符集的一部分，这意味着仅支持基本的英文字符和符号。在 C 区域设定中，字符串的排序和比较是基于简单的二进制值比较，这与本地化的语言设置相比相对简单。因此，C.UTF-8 结合了 C 区域设定和 UTF-8 字符编码的优势。使用 C.UTF-8 时，系统默认语言环境保持简单和高效，同时支持更广泛的字符集，特别是多语言和非英语字符。这样可以在需要兼容性的同时，提供对全球化字符的支持。
dnf search locale zhdnf -y install glibc-langpack-zhlocalectl set-locale LANG=zh_CN.UTF-8source /etc/locale.confapt update -y && apt install language-pack-zh-hans -yupdate-locale LANG=zh_CN.UTF-8 LANGUAGE=zh_CN:zhsource /etc/default/localeNOTE
如果 C 语言不支持中文，那么简体中文 Windows 操作系统将无从谈起，我们只能被迫使用英文 Windows 操作系统，这对计算机的传播而言将会是一种巨大的阻碍。
NOTE
上文提及过，在现代编程中，窄字符通常与 UTF-8 编码关联，特别是在处理文本输入、输出和网络传输时。尽管 UTF-8 是变长编码，由于其高效的空间利用和对 ASCII 的优化，通常与窄字符概念关联。而宽字符通常与 UTF-16 编码或 UTF-32编码关联，这些编码使用更大的固定或半固定长度来表示字符，适合处理更大的字符集。
NOTE
不同的编译器可以使用不同的整数类型，来存储宽字符，这对于跨平台开发来说，非常不友好。
wchar_t 类型，用来存储宽字符类型。 NOTE
wchar_t 中的 w是 wide 的首字母，t 是 type 的首字母，所以 wchar_t 就是宽字符类型，足够见名知意。wchar_t 是用 typedef 关键字定义的一个别名，后文讲解，wchar_t 在不同的编译器下长度不一样。wchar_t 类型位于 <wchar.h> 头文件中，它使得代码在具有良好移植性的同时，也节省了不少内存，以后我们就用它来存储宽字符。'' 括起来，来表示字符，如：'A'、'&' 等。但是，如果要想表示宽字符，就需要加上 L 前缀了，如：L'A'、L'中'。NOTE
宽字符字面量中的 L 是 Long 的缩写，意思是比普通的字符（char）要长。
#include <stddef.h>
int main() {
/* 存储宽字符，如：中文 */
wchar_t a = L'中';
wchar_t b = L'中';
wchar_t c = L'中';
wchar_t d = L'中';
wchar_t e = L'中';
return 0;
}putchar 函数和 printf 函数来进行输出了，需要使用 putwchar 函数和 wprintf 函数。NOTE
putchar 函数和 printf 函数，只能输出窄字符，即：char 类型表示的字符。putwchar 函数可以用来输出宽字符，用法和 putchar 函数类似。wprintf函数可以用来输出宽字符，用法和 printf 函数类型，只不过格式占位符是 %lc 。setlocale 函数进行本地化设置，告诉程序如何才能正确地处理各个国家的语言文化。#include <locale.h>
#include <stddef.h>
#include <wchar.h>
int main() {
/* 存储宽字符，如：中文 */
wchar_t a = L'中';
wchar_t b = L'国';
wchar_t c = L'人';
wchar_t d = L'你';
wchar_t e = L'好';
// 将本地环境设置为简体中文
setlocale(LC_ALL, "zh_CN.UTF-8");
// 使用专门的 putwchar 输出宽字符
putwchar(a);
putwchar(b);
putwchar(c);
putwchar(d);
putwchar(e);
putwchar(L'\\n'); // 只能使用宽字符
// 使用通用的 wprintf 输出宽字符
wprintf(L"%lc %lc %lc %lc %lc\\n", a, b, c, d, e);
return 0;
}L 前缀，就变成了宽字符串，即：它包含的每个字符都是宽字符，一律采用 UTF-16 或者 UTF-32 编码。NOTE
%ls。L前缀的窄字符串也可以处理中文，我们之前就在 printf 函数中，使用格式占位符 %s 输出含有中文的字符串，至于为什么，看下文讲解。#include <locale.h>
#include <stddef.h>
#include <wchar.h>
int main() {
/* 存储宽字符，如：中文 */
wchar_t a[] = L"中国人";
wchar_t *b = L"你好";
// 将本地环境设置为简体中文
setlocale(LC_ALL, "zh_CN.UTF-8");
// 使用通用的 wprintf 输出字符串
wprintf(L"%ls %ls\\n", a, b);
return 0;
}char 类型的窄字符才会使用 ASCII 编码。而 char 类型的窄字符串、wchar_t 类型的宽字符和宽字符串都不使用 ASCII 编码。wchar_t 类型的宽字符和宽字符串使用 UTF-16 或者 UTF-32 编码，这个在上文已经讲解了，现在只剩下 char 类型的窄字符串没有讲解了，这也是下文的重点。NOTE
char 类型的窄字符串，C 语言并没有规定使用哪一种特定的编码，只要选用的编码能够适应当前的环境即可。换言之，char 类型的窄字符串的编码与操作系统以及编译器有关。char 类型的窄字符串一定不是 ASCII 编码，因为 ASCII 编码只能显示拉丁体系的文字，而不能输出中文、日文、韩文等。#include <stdio.h>
int main() {
// 存储字符串
char str[] = "我";
char *str2 = "爱你";
puts(str); // 我
puts(str2); // 爱你
// 存储字符串
char str3[] = "你";
char *str4 = "是好人";
printf("%s\\n", str3); // 你
printf("%s\\n", str4); // 是好人
return 0;
}"我"、"爱你"、"你"、"是好人"就是需要被处理的窄字符串，当程序运行的时候，它们会被加载进内存。并且，这些字符串中是包含中文的，所以一定不会使用 ASCII 编码。char 类型的窄字符，在 C 语言中，使用的是 ASCII 编码。wchar_t 类型的宽字符和宽字符串，在 C 语言中，使用的 UTF-16 编码或者 UTF-32 编码，它们都是基于 Unicode 字符集的。char 类型的窄字符串，微软的 MSVC 编译器使用本地编码，GCC、LLVM/Clang 使用和源文件编码相同的编码。<stdio.h> 头文件中的 putchar、puts、printf 函数只能用来处理窄字符。<wchar.h> 头文件中的 putwchar、wprintf 函数只能用来处理宽字符。IMPORTANT
std::string 和 Java 中的 String。并且，现代编程语言通常会自动管理内存，这样开发者就不需要手动处理字符串的内存分配和释放，从而减少了内存泄漏和缓冲区溢出等问题。当然，现代编程语言通常内置了对各种字符编码的支持，能够方便地处理不同语言的字符，如：Java 的 String 类和 Python 的 str 类型都默认支持 Unicode，可以轻松处理中文等多字节字符。编码字符集，即：写代码的时候所使用的字符集。NOTE
源文件需要保存到硬盘，或者在网络上传输，使用的编码要尽量节省存储空间，同时要方便跨国交流，所以一般使用 UTF-8，这就是选择编码字符集的标准。
运行字符集，即：程序运行时所使用的字符集。NOTE
程序中的字符或者字符串，在程序运行后必须被载入到内存，才能进行后续的处理，对于这些字符来说，要尽量选用能够提高处理速度的编码，如：UTF-16 和 UTF-32 编码就能够快速定位（查找）字符。