13 数据存储单位与 C 语言整数类型：从位到艾字节、常见整数类型及其范围、字面量后缀、精确宽度类型详解

1 数据存储单位

        在计算机科学领域，数据存储采用分层级的单位体系，各层级单位以 2 的幂次方为换算基础，而非传统数学中的 10 的幂次方。

        以下是常见的数据存储单位介绍：

• 位（bit，b）是计算机中的最小存储单位，它仅能表示一个二进制位，即 0 或 1。这是计算机处理数据的基础，所有的信息在计算机中最终都以二进制位的形式存在。
• 字节（Byte，B）是计算机中的基本存储单元，由 8 个二进制位组成，即 1 Byte = 8 bit。它是衡量数据量的基本单位，在文件存储、数据传输等方面广泛应用。
• 千字节（Kilobyte，KB）是字节的上一级单位，1 KB = 1024 Bytes。在日常使用中，KB 常用于表示较小的文件大小，如简单的文本文件、小型图片等，也可用于衡量内存使用量。
• 兆字节（Megabyte，MB）是比千字节更大的数据存储单位，1 MB = 1024 KB。它常用于描述中等规模的文件大小，例如软件安装包、常见的音乐文件、标清视频文件等。
• 吉字节（Gigabyte，GB）是更大的数据存储单位，1 GB = 1024 MB。在存储设备领域，GB 常用于衡量硬盘驱动器、固态硬盘、USB 闪存盘等的存储容量；在文件方面，常用于描述大型软件、高清视频等的大小。
• 太字节（Terabyte，TB）是更大一级的数据存储单位，1 TB = 1024 GB。TB 级别的存储通常应用于企业级存储解决方案、数据中心，以满足大量数据的存储需求，同时也适用于个人用户进行大量数据备份。
• 拍字节（Petabyte，PB）是更为庞大的数据存储单位，1 PB = 1024 TB。它主要用于超大规模的数据中心、云计算平台以及大数据分析等领域，这些领域需要处理和存储海量的数据。
• 艾字节（Exabyte，EB）是目前常见的数据存储单位中最大的，1 EB = 1024 PB。EB 级别的存储主要用于应对超大规模的数据存储需求，例如全球互联网数据的存储、大型科研项目产生的大量数据存储等。

---

2 C 语言数据类型概述

        程序的核心功能在于对数据进行计算与处理，而为了更高效地管理这些数据，我们常对其进行分类。以容器为例，依据其容量和形状的差异，我们可以将其划分为大杯、中杯、大碗、小碗等不同类别。每种容器都有其独特的设计，适合盛装不同的物品。如下图所示，我们可以看到各种形状和大小的容器，它们各自具有不同的用途和容量。这种分类方式不仅有助于我们更好地理解和组织数据，还能在实际应用中提高效率和便利性。

        C 语言依据数据的特性和用途，对其进行了精细的类型划分。不同类型的数据在内存中会占用不同大小的存储空间，这种设计使得程序能够更高效地管理和利用内存资源。

---

3 整数类型

3.1 基本概念

        整数类型，简称整型，是用于存储整数值的数据类型，例如：12、30、3456 等。

3.2 常见整型类型及范围

        在 C 语言中，整型数据可以根据其存储空间大小和取值范围进一步细分。以下是常见的整型类型及其对应的存储大小与取值范围：

类型	存储大小	值范围
short
signed short	2 字节	-32,768 (-2^15) 到 32,767 (2^15 - 1)
unsigned short	2 字节	0 到 65,535 (2^16 - 1)
int
signed int	16 位系统：2 字节 32 位系统：4 字节	16 位：-32,768 (-2^15) 到 32,767 (2^15 - 1) 32 位：-2,147,483,648 (-2^31) 到 2,147,483,647 (2^31 - 1)
unsigned int	16 位系统：2 字节 32 位系统：4 字节	16 位：0 到 65,535 (2^16 - 1) 32 位：0 到 4,294,967,295 (2^32 - 1)
long
signed long	32 位系统：4 字节 64 位系统：8 字节	32 位：-2,147,483,648 (-2^31) 到 2,147,483,647 (2^31 - 1) 64 位：-9,223,372,036,854,775,808 (-2^63) 到 9,223,372,036,854,775,807 (2^63 - 1)
unsigned long	4 或 8 字节	32 位：0 到 4,294,967,295 (2^32 - 1) 64 位：0 到 18,446,744,073,709,551,615 (2^64 - 1)
long long
signed long long	8 字节	-9,223,372,036,854,775,808 (-2^63) 到 9,223,372,036,854,775,807 (2^63 - 1)
unsigned long long	8 字节	0 到 18,446,744,073,709,551,615 (2^64 - 1)

3.3 整型类型注意事项

3.3.1 存储大小

        整型类型的存储大小受操作系统、编译器和硬件平台的共同影响，因此在不同环境下可能会有所不同。例如，在某些平台上，long 和 int 的大小可能相同，但这种假设并不具有通用性，不能依赖于此。

        为了确保程序的可移植性，可以使用 sizeof 运算符（将在后续学习中详细讲解）来确定具体平台上的类型大小。通过这种方式，可以在不同环境中准确了解变量占用的内存空间。

3.3.2 符号类型

        整型分为有符号（signed）和无符号（unsigned）两种：

1. 有符号类型（signed）：可以表示正数、负数和零，适用于需要处理负值的场景。

2. 无符号类型（unsigned）：只能表示非负整数（即零和正数），适用于仅需处理正值的情况。

        在 C 语言中，默认情况下整型为有符号类型。例如，int 等价于 signed int，因此可以省略 signed 关键字直接写作 int。如果需要使用无符号类型，则必须显式声明为 unsigned。

3.3.3 类型选择

        根据实际需求合理选择整型类型，可以在性能、内存占用和兼容性之间取得平衡：

• 节省空间：当数据范围较小时，可以选择 short 类型（如计数器、小范围数值）。
• 通用场景：优先使用 int 类型，因为它在大多数平台上具有良好的性能与兼容性，适合大多数常规应用场景。
• 大数需求：当需要处理较大数值时，应选择 long long 类型（如文件大小、高精度计算等场景）。

3.4 多种整数类型设计原因

        C 语言提供多种整数类型（如 short、int、long、long long 及其 signed/unsigned 变体），其设计初衷是为了满足多样化的编程需求，同时兼顾性能、可移植性和代码安全性。以下是这些类型设计背后的核心原因及其详细分析。

3.4.1 适配硬件差异

        不同硬件平台的存储能力、字长（word size）和性能特性各不相同，C 语言通过提供多种整数类型，使代码能够高效适配不同硬件环境。

• 高性能计算场景：在需要处理大数或高精度计算的场景中（如科学计算、金融建模），long long 类型（通常为 64 位）提供了更大的数值范围（-2^63 到 2^63 - 1），避免了溢出问题，同时利用现代 64 位处理器的原生支持提升计算效率。
• 嵌入式系统场景：在资源受限的嵌入式设备（如微控制器）中，short 类型（通常为 16 位）通过减少内存占用（相比 int 或 long），降低了硬件资源需求，从而延长电池寿命或降低硬件成本。
• 跨平台兼容性：不同硬件平台的字长可能不同（如 16 位、32 位、64 位），C 语言通过提供多种类型，使程序员能够根据目标平台的特性选择合适的类型，确保代码在不同硬件上均能高效运行。

3.4.2 满足数值范围需求

        C 语言通过类型大小区分数值范围，为不同应用场景提供了灵活的选择。

• 无符号类型的扩展性：unsigned 类型通过移除符号位，将数值范围扩展至非负数（如 unsigned int 的范围为 0 到 2^32 - 1），适用于以下场景：

  • 计数器：循环计数器通常无需负数，使用 unsigned 类型可避免溢出问题。
  • 位操作：无符号类型与位掩码操作天然兼容，简化了位级编程。
  • 数组索引：索引值始终为非负数，使用 unsigned 类型可避免负值错误。

• 大范围数值处理：long long 类型（64 位）适用于需要处理大范围整数的场景（如文件大小、时间戳、大数运算），其数值范围远超 int 或 long，避免了溢出风险。

• 小范围数值优化：short 类型（16 位）适用于数值范围较小的场景（如状态码、布尔值集合），通过减少内存占用提升性能。

3.4.3 提升可移植性与兼容性

        C 语言的设计目标是跨平台通用性，多种整数类型的设计有助于在不同编译器和硬件平台上保持代码的一致性。

• 最小范围保证：C 标准未强制固定类型大小，但规定了每种类型的最小范围（如 int 至少为 16 位，long 至少为 32 位）。这种灵活性允许编译器根据目标平台优化类型大小，同时确保代码在不同平台上均能正确运行。

• 历史代码兼容性：保留传统类型（如 long）和未明确大小的类型（如 int）是为了兼容早期 C 代码。许多遗留系统依赖这些类型的默认行为，强制改变可能导致现有代码无法编译或行为异常。

• 跨平台一致性：通过提供多种类型，程序员可以根据需求显式选择类型（如 int32_t、uint64_t），避免因平台差异导致的隐式行为变化，提升代码的可维护性。

3.4.4 优化性能与代码明确性

        C 语言通过类型设计优化内存对齐和访问效率，同时减少隐式转换错误，提升代码的安全性和可读性。

• 硬件对齐优化：现代处理器对特定大小的数据类型（如 4 字节的 int 或 8 字节的 long long）有对齐要求。使用与硬件对齐要求匹配的类型（如 4 字节对齐的 int）可显著提升内存访问速度，减少 CPU 周期浪费。

• 显式类型区分：signed 和 unsigned 类型的显式区分避免了隐式转换错误。例如：

  • 算术运算：无符号类型在溢出时表现为模运算，而有符号类型可能导致未定义行为（后续学习）。
  • 比较操作：signed 和 unsigned 类型混合比较可能导致意外结果（如负数被解释为大整数）。
  • 通过显式声明类型，程序员可清晰表达意图，减少潜在错误。

• 代码可读性与维护性：使用语义明确的类型（如 size_t 表示内存大小，ptrdiff_t 表示指针差值）提升了代码的可读性，使其他开发者能够快速理解变量用途。

3.5 多种整数类型大小比较

        C 语言标准通过定义整数类型的相对大小关系和最小位宽要求，在保证跨平台灵活性和可移植性的同时，为程序员提供了明确的类型选择依据。以下是基于 C99 标准的详细分析：

3.5.1 相对大小关系

        C 语言标准规定了整数类型的相对大小顺序，但未强制固定每种类型的具体位数。这种设计允许编译器根据目标平台的特性优化类型大小，同时确保类型之间的层级关系一致。

层级关系：

        char ≤ short ≤ int ≤ long ≤ long long

• char：最小整数类型，通常用于存储字符或小范围整数。其大小固定为 1 字节（8 位），但具体表示范围（有符号或无符号）由实现决定。
• short：至少与 char 一样大，但通常更大（如 16 位）。适用于需要节省内存的小范围整数。
• int：至少与 short 一样大，通常是编译器默认的高效整数类型（如 32 位）。
• long：至少与 int 一样大，常用于需要更大范围的整数（如 32 位或 64 位）。
• long long：至少与 long 一样大，提供最大范围的整数类型（通常为 64 位）。

设计目的：

        层级关系确保了类型之间的兼容性。例如，将 short 赋值给 int 或 long 时不会丢失信息，因为目标类型始终不小于源类型。

3.5.2 最小位宽要求

        C 标准规定了每种整数类型的最小位宽，确保类型在不同平台上具有一致的最小表示能力。

• 类型	最小位宽	典型位宽（常见实现）	说明
  char	8 位	8 位	固定为 1 字节，用于字符或小整数。
  short	16 位	16 位	至少 16 位，适用于小范围整数。
  int	16 位	32 位（32/64 位系统）	至少 16 位，通常是编译器默认的高效整数类型。
  long	32 位	32 位（32 位系统）	至少 32 位，64 位系统上可能为 64 位（如 Linux x86_64）。
  		64 位（64 位系统）
  long long	64 位	64 位	至少 64 位，提供最大范围的整数类型。

• 灵活性：编译器可根据平台特性调整类型大小（如 int 在 16 位系统可能为 16 位，在 32/64 位系统通常为 32 位）。
• 一致性：最小位宽保证了类型在不同平台上的基本表示能力（如 long long 始终至少为 64 位）。
• 性能优化：编译器可选择与目标平台字长对齐的类型（如 32 位系统使用 32 位 int），提升内存访问效率。

3.6 字面量后缀规则

        字面量是源代码中用于直接表示固定值的符号，整数类型的字面量可以通过后缀显式指定其类型。

        C 语言提供了一系列后缀，用于将字面量转换为特定的整数类型，从而避免类型推断的歧义并提升代码的可读性和安全性。

3.6.1 默认类型与自动提升

        如果整数字面量没有指定后缀，编译器会根据字面量的值和上下文来推断其类型。

• 通常情况下，如果字面量的值在 int 类型的范围内，它会被视为 int 类型。
• 如果超出 int 的范围但在 long 的范围内，它可能会被提升为 long 类型（具体取决于值的大小和平台实现）。
• 如果超出 long 的范围，并且在 long long 的范围内，它可能会被提升为 long long 类型（具体取决于值的大小和平台实现）。

int a = 123;  // 123 默认是 int 类型

3.6.2 后缀类型说明

        C 语言通过后缀显式指定字面量的类型，常用后缀及其含义如下：

后缀	类型	示例	说明
无	int	123	默认类型，适用于小范围整数。
l/L	long	123L	表示 long 类型，建议使用大写 L 以避免与数字 1 混淆。
ll/LL	long long	123LL	表示 long long 类型，适用于大范围整数。
u/U	unsigned int	123U	表示无符号整数，扩展正数范围。
ul/Ul/uL/UL 或 lu/Lu/lU/LU	unsigned long	123UL	无符号 long 类型，后缀顺序无关。
ull/Ull/uLL/ULL 或 llu/LLu/llU/LLU	unsigned long long	123ULL	无符号 long long 类型，适用于大范围无符号整数。

3.6.3 后缀使用规则与最佳实践

• 后缀组合：
  • 无符号后缀（u/U）与长度后缀（l/L、ll/LL）可自由组合，顺序无关。例如：

unsigned long a = 123UL;        // 等价于 123LU
unsigned long long b = 123ULL;  // 等价于 123LLU
unsigned long long b = 123uLL;  // 等价于 123ULL

• 大小写建议：

  • 使用大写 L 表示 long 类型，避免与小写字母 l（易与数字 1 混淆）混淆。
  • 无符号后缀 u 可使用小写，但为保持一致性，也可统一使用大写 U。
  • 注意：Ll 或 lL 是非法的，因为标准要求后缀的两个字母必须相同（要么都是大写，要么都是小写）。

• 避免歧义：

  • 在需要明确类型时，始终使用后缀。例如：

long long largeNumber = 9223372036854775807LL;  // 明确指定 long long 类型
unsigned int bitmask = 0xFFFFFFFFU;            // 明确指定 unsigned int 类型

3.6.4 特殊类型与注意事项

• unsigned short 无专用后缀：
  • C 语言未提供 unsigned short 的专用后缀。若需表示 unsigned short 类型，可通过显式类型转换。

unsigned short value = (unsigned short)12345;

• 字面量范围限制：
  • 字面量的值必须在其指定类型的表示范围内，否则会导致编译错误或未定义行为。

unsigned int x = -1;  // 错误：-1 超出 unsigned int 范围

3.7 格式占位符与整型类型对应关系

3.7.1 格式占位符与类型对照表

        格式占位符用于在格式化输入输出中指定变量的类型，确保数据正确解析和显示。

格式说明符	对应的整型类型	示例
%hd	short	short a = 123;
%hu	unsigned short	unsigned short b = 123;
%d	int	int c = 123;
%u	unsigned int	unsigned int d = 123;
%ld	long	long e = 123L;
%lu	unsigned long	unsigned long f = 123UL;
%lld	long long	long long g = 123LL;
%llu	unsigned long long	unsigned long long h = 123ULL;

关键注意事项：

1. 顺序严格性：格式占位符中的类型修饰符（如 ll、u）必须按固定顺序书写：
   • %lld 表示 long long，不能写成 %dll。
   • %llu 表示 unsigned long long，不能写成 %lul。
2. C99 标准支持：
   • long long 类型及其占位符 %lld、%llu 是 C99 标准引入的。
   • 早期 C 标准（如 C89）可能不支持这些占位符，需使用编译器扩展或避免使用 long long。
3. 字面量后缀灵活性：整数字面量的后缀（如 UL、LU）顺序可互换（123UL 等价于 123LU），但格式占位符必须严格遵守顺序。

3.7.2 示例：格式化输出多种整型数据

#include <stdio.h>int main()
{// short 类型short a1 = 10; // 等同于 signed shortsigned short a2 = -10;unsigned short a3 = 20;printf("short a1=%hd; signed short a2=%hd; unsigned short a3=%hu\n", a1, a2, a3);// 输出: short a1=10; signed short a2=-10; unsigned short a3=20// int 类型int b1 = 100; // 等同于 signed intsigned int b2 = -100;unsigned int b3 = 200u; // 后缀 'u' 表示 unsignedunsigned b4 = 300U;     // 等同于 unsigned intprintf("int b1=%d; signed int b2=%d; unsigned int b3=%u; unsigned b4=%u\n", b1, b2, b3, b4);// 输出: int b1=100; signed int b2=-100; unsigned int b3=200; unsigned b4=300// long 类型long c1 = 1000L; // 推荐大写 'L'，避免与数字 1 混淆signed long c2 = -1000L;unsigned long c3 = 2000UL; // 推荐大写 'UL'printf("long c1=%ld; signed long c2=%ld; unsigned long c3=%lu\n", c1, c2, c3);// 输出: long c1=1000; signed long c2=-1000; unsigned long c3=2000// long long 类型（C99 及以后）long long d1 = 10000LL; // 推荐大写 'LL'，避免与数字 1 混淆signed long long d2 = -10000LL;unsigned long long d3 = 20000ULL; // 推荐大写 'ULL'printf("long long d1=%lld; signed long long d2=%lld; unsigned long long d3=%llu\n", d1, d2, d3);// 输出: long long d1=10000; signed long long d2=-10000; unsigned long long d3=20000return 0;
}

        程序在 VS code 中的运行结果如下所示：

3.7.3 示例：格式化输入输出多种整型数据

#include <stdio.h>int main()
{// 定义各种整型变量short s;                // 有符号短整型unsigned short us;      // 无符号短整型int i;                  // 有符号整型unsigned int ui;        // 无符号整型long l;                 // 有符号长整型unsigned long ul;       // 无符号长整型long long ll;           // 有符号长长整型（C99 及以后）unsigned long long ull; // 无符号长长整型（C99 及以后）// 输入有符号短整型printf("Enter a short integer: ");scanf("%hd", &s); // 使用 %hd 格式说明符读取 short 类型// 输入无符号短整型printf("Enter an unsigned short integer: ");scanf("%hu", &us); // 使用 %hu 格式说明符读取 unsigned short 类型// 输入有符号整型printf("Enter an integer: ");scanf("%d", &i); // 使用 %d 格式说明符读取 int 类型// 输入无符号整型printf("Enter an unsigned integer: ");scanf("%u", &ui); // 使用 %u 格式说明符读取 unsigned int 类型// 输入有符号长整型printf("Enter a long integer: ");scanf("%ld", &l); // 使用 %ld 格式说明符读取 long 类型// 输入无符号长整型printf("Enter an unsigned long integer: ");scanf("%lu", &ul); // 使用 %lu 格式说明符读取 unsigned long 类型// 输入有符号长长整型printf("Enter a long long integer: ");scanf("%lld", &ll); // 使用 %lld 格式说明符读取 long long 类型// 输入无符号长长整型printf("Enter an unsigned long long integer: ");scanf("%llu", &ull); // 使用 %llu 格式说明符读取 unsigned long long 类型// 打印输入的值以验证printf("Values entered:\n");printf("Short: %hd\n", s);                 // 输出 short 类型printf("Unsigned Short: %hu\n", us);       // 输出 unsigned short 类型printf("Int: %d\n", i);                    // 输出 int 类型printf("Unsigned Int: %u\n", ui);          // 输出 unsigned int 类型printf("Long: %ld\n", l);                  // 输出 long 类型printf("Unsigned Long: %lu\n", ul);        // 输出 unsigned long 类型printf("Long Long: %lld\n", ll);           // 输出 long long 类型printf("Unsigned Long Long: %llu\n", ull); // 输出 unsigned long long 类型return 0;
}

        程序在 VS code 中的运行结果如下所示：

3.8 精确宽度类型

        在 C 语言中，传统的整数类型（如 short、int、long）在不同计算机架构上的字节宽度可能不同。这种不确定性可能导致代码在不同平台上的行为不一致，尤其是在嵌入式开发中，精确控制数据宽度至关重要。

        为了提高代码的可移植性和一致性，C99 标准引入了 <stdint.h> 头文件，其中定义了一系列精确宽度整数类型。这些类型确保了特定位宽的有符号和无符号整数，无论在哪种平台上编译，都能保证数据类型的大小。

3.8.1 类型列表

类型名称	含义
int8_t	8 位有符号整数
int16_t	16 位有符号整数
int32_t	32 位有符号整数
int64_t	64 位有符号整数
uint8_t	8 位无符号整数
uint16_t	16 位无符号整数
uint32_t	32 位无符号整数
uint64_t	64 位无符号整数

• int64_t 和 uint64_t 需要使用 LL 和 ULL 后缀表示大整数 

3.8.2 使用演示

#include <stdio.h>
#include <stdint.h>int main()
{// 声明一个 8 位有符号整数变量 x8，使用精确宽度类型 int8_t// 无论在哪个平台上编译，x8 始终是 8 位（1 个字节）int8_t x8 = -100;// 声明一个 8 位无符号整数变量 u8，使用精确宽度类型 uint8_t// 无论在哪个平台上编译，u8 始终是 8 位（1 个字节）uint8_t u8 = 200;// 声明一个 16 位有符号整数变量 x16，使用精确宽度类型 int16_t// 无论在哪个平台上编译，x16 始终是 16 位（2 个字节）int16_t x16 = 30000;// 声明一个 16 位无符号整数变量 u16，使用精确宽度类型 uint16_t// 无论在哪个平台上编译，u16 始终是 16 位（2 个字节）uint16_t u16 = 60000;// 声明一个 32 位有符号整数变量 x32，使用精确宽度类型 int32_t// 无论在哪个平台上编译，x32 始终是 32 位（4 个字节）int32_t x32 = 45933945;// 声明一个 32 位无符号整数变量 u32，使用精确宽度类型 uint32_t// 无论在哪个平台上编译，u32 始终是 32 位（4 个字节）uint32_t u32 = 4000000000U;/* int64_t 和 uint64_t 需要使用 LL 和 ULL 后缀表示大整数*/// 声明一个 64 位有符号整数变量 x64，使用精确宽度类型 int64_t// 无论在哪个平台上编译，x64 始终是 64 位（8 个字节）int64_t x64 = -9000000000000000000LL;// 声明一个 64 位无符号整数变量 u64，使用精确宽度类型 uint64_t// 无论在哪个平台上编译，u64 始终是 64 位（8 个字节）uint64_t u64 = 18000000000000000000ULL;// 打印各个变量的值printf("x8 (8-bit signed): %d\n", x8);printf("u8 (8-bit unsigned): %u\n", u8);printf("x16 (16-bit signed): %d\n", x16);printf("u16 (16-bit unsigned): %u\n", u16);printf("x32 (32-bit signed): %d\n", x32);printf("u32 (32-bit unsigned): %u\n", u32);printf("x64 (64-bit signed): %lld\n", x64);printf("u64 (64-bit unsigned): %llu\n", u64);return 0;
}

        程序在 VS code 中的运行结果如下所示：

3.8.3 实现原理

        这些类型实际上是类型别名，编译器会根据目标平台的特性，将它们映射到底层的基本类型（如 int、long 等）。例如：

• 在某个系统中，如果 int 类型是 32 位的，int32_t 会被映射到 int。
• 如果 long 类型是 32 位的，int32_t 则可能被映射到 long。

        这种映射机制确保了：

• 跨平台一致性：无论在哪种平台上，int32_t 始终是 32 位。
• 代码可读性：开发者可以明确指定所需的位宽，无需担心底层类型的差异。

3.8.4 查看头文件源代码

        我们可以通过按住【Ctrl 键】并点击鼠标左键的方式，查看程序中数据类型的头文件源代码。

        当我们将鼠标悬停在 int8_t 上，并按下【Ctrl 键】的同时点击鼠标左键，就会跳转到 <stdint.h> 头文件源代码中该类型的定义部分。

        <stdint.h> 头文件中定义精确宽度数据类型的代码片段如下所示：

        我们可以看出，在 <stdint.h> 头文件中，定义了一系列具有精确宽度的整数类型别名。这些类型别名提供了一种标准化的方式来指定数据类型的位宽，使得在不同平台上进行编程时，能够确保数据类型的一致性。这对于跨平台编程尤其重要，因为不同平台（如 32 位和 64 位系统）上基本数据类型的位宽可能会有所不同。

1. typedef signed char int8_t; 和 typedef unsigned char uint8_t;
   • 定义了 8 位有符号和无符号整数类型。int8_t 表示 8 位有符号整数，uint8_t 表示 8 位无符号整数。
2. typedef short int16_t; 和 typedef unsigned short uint16_t;
   • 定义了 16 位有符号和无符号整数类型。int16_t 表示 16 位有符号整数，uint16_t 表示 16 位无符号整数。
3. typedef int int32_t; 和 typedef unsigned int uint32_t;
   • 定义了 32 位有符号和无符号整数类型。int32_t 表示 32 位有符号整数，uint32_t 表示 32 位无符号整数。
4. __MINGW_EXTENSION typedef long long int64_t; 和 __MINGW_EXTENSION typedef unsigned long long uint64_t;
   • 定义了 64 位有符号和无符号整数类型。int64_t 表示 64 位有符号整数，uint64_t 表示 64 位无符号整数。
   • __MINGW_EXTENSION 是一个特定于 MinGW 编译器的扩展，用于支持一些非标准的特性。