002 《C++ 整数类型深度解析：从基础到高级》
🌟🌟🌟本文由Gemini 2.5 Flash Preview 04-17生成，用来辅助学习。🌟🌟🌟
书籍大纲
▮▮ 1. 绪论：C++ 数据类型概述与整数类型的地位
▮▮▮▮ 1.1 C++ 数据类型的基本分类
▮▮▮▮ 1.2 基本数据类型（Fundamental Types）
▮▮▮▮ 1.3 整数类型（Integer Types）在 C++ 中的核心地位
▮▮▮▮ 1.4 本书目标与读者导引
▮▮ 2. C++ 标准整数类型
▮▮▮▮ 2.1 有符号整数类型（Signed Integer Types）
▮▮▮▮ 2.2 无符号整数类型（Unsigned Integer Types）
▮▮▮▮ 2.3 类型修饰符（Type Specifiers）
▮▮▮▮ 2.4 char 类型的特殊性
▮▮ 3. 整数类型的属性：大小、范围与表示
▮▮▮▮ 3.1 类型大小（Size of Types）与 sizeof 运算符
▮▮▮▮ 3.2 数值范围（Value Range）
▮▮▮▮▮▮ 3.2.1 有符号整数的范围与二进制补码（Two's Complement）表示
▮▮▮▮▮▮ 3.2.2 无符号整数的范围
▮▮▮▮ 3.3 跨平台的可移植性问题
▮▮▮▮ 3.4 标准库中的范围信息：<limits> 和 <climits>
▮▮ 4. 整数的字面量（Literals）与初始化
▮▮▮▮ 4.1 整数字面量的不同表示
▮▮▮▮ 4.2 字面量的类型后缀（Suffixes）
▮▮▮▮ 4.3 整数字面量的默认类型推断
▮▮▮▮ 4.4 数字分隔符（Digit Separators, C++14+）
▮▮▮▮ 4.5 整数变量的初始化
▮▮ 5. 整数运算
▮▮▮▮ 5.1 算术运算符（Arithmetic Operators）
▮▮▮▮▮▮ 5.1.1 整数除法和取模
▮▮▮▮▮▮ 5.1.2 算术溢出（Arithmetic Overflow）
▮▮▮▮ 5.2 位运算符（Bitwise Operators）
▮▮▮▮▮▮ 5.2.1 左移和右移的规则与未定义行为
▮▮▮▮ 5.3 比较运算符（Comparison Operators）
▮▮▮▮ 5.4 复合赋值运算符（Compound Assignment Operators）
▮▮ 6. 整数类型转换
▮▮▮▮ 6.1 隐式类型转换（Implicit Type Conversion）
▮▮▮▮ 6.2 整型提升（Integer Promotions）规则
▮▮▮▮ 6.3 算术转换（Arithmetic Conversions）
▮▮▮▮ 6.4 显式类型转换（Explicit Type Conversion）/ 强制类型转换（Casts）
▮▮▮▮ 6.5 转换中的截断（Truncation）与符号扩展（Sign Extension）
▮▮ 7. 有符号与无符号整数的交互与陷阱
▮▮▮▮ 7.1 有符号与无符号整数的比较
▮▮▮▮ 7.2 有符号与无符号整数的算术运算
▮▮▮▮ 7.3 将负数转换为无符号类型
▮▮▮▮ 7.4 常见的有符号/无符号错误模式
▮▮ 8. 整数类型的使用最佳实践与常见问题
▮▮▮▮ 8.1 选择合适的整数类型
▮▮▮▮ 8.2 警惕整数溢出
▮▮▮▮ 8.3 安全地进行类型转换
▮▮▮▮ 8.4 使用无符号类型时的注意事项
▮▮▮▮ 8.5 利用编译器警告
▮▮ 9. 高级主题与特定用途整数类型
▮▮▮▮ 9.1 固定宽度整数类型（Fixed-width Integer Types, C++11+）
▮▮▮▮▮▮ 9.1.1 确切宽度类型（Exact-width Types）
▮▮▮▮▮▮ 9.1.2 最小宽度类型（Minimum-width Types）
▮▮▮▮▮▮ 9.1.3 最快最小宽度类型（Fastest minimum-width types）
▮▮▮▮▮▮ 9.1.4 指针宽度类型（Pointer-width Types）
▮▮▮▮▮▮ 9.1.5 最大宽度类型（Greatest-width Types）
▮▮▮▮ 9.2 size_t 和 ptrdiff_t
▮▮▮▮ 9.3 位字段（Bit Fields）
▮▮▮▮ 9.4 字节序（Endianness）对整数表示的影响
▮▮ 10. C++ 标准演进中的整数类型相关特性
▮▮▮▮ 10.1 C++11: 固定宽度整数与 <cstdint>
▮▮▮▮ 10.2 C++14: 二进制字面量与数字分隔符
▮▮▮▮ 10.3 C++17: 结构化绑定与整数类型
▮▮▮▮ 10.4 C++20 及后续: 潜在的相关特性
▮▮ 附录A: 常用整数类型及其最小保证范围
▮▮ 附录B: 推荐的头文件与标准库工具
▮▮ 附录C: 术语对照表
▮▮ 附录D: 参考文献
1. 绪论：C++ 数据类型概述与整数类型的地位
欢迎来到本书！📚 C++ 是一门功能强大、应用广泛的编程语言，它在系统编程、游戏开发、高性能计算等领域占据着重要的地位。要精通 C++，深入理解其基本构成要素至关重要，而数据类型（Data Types）正是这些要素的基石。数据类型定义了变量可以存储的数据种类、数据在内存中的表示方式以及可以在这些数据上执行的操作。
在 C++ 的数据类型家族中，整数类型（Integer Types）是最基础、最常用的一类。它们用于表示没有小数部分的数值，是实现计数、索引、尺寸计算、标志位处理等核心逻辑的必要工具。然而，尽管看似简单，C++ 的整数类型却蕴含着丰富的细节和潜在的陷阱，特别是在涉及不同类型之间的交互、溢出或跨平台移植性时。
本书旨在带领您系统、全面地深入解析 C++ 中的整数类型。无论您是刚开始接触 C++ 的新手，希望打下坚实的基础；还是有一定经验的开发者，想要理解整数类型更深层的机制以写出更安全、高效的代码；抑或是寻求精进的专家，希望掌握标准细节和高级用法，本书都将为您提供有价值的洞见。
本章将首先概述 C++ 的数据类型体系，明确整数类型在其中的位置，并强调透彻理解整数类型对于 C++ 编程的重要性。最后，将介绍本书的结构和建议的阅读方式。
1.1 C++ 数据类型的基本分类
C++ 的数据类型可以从不同的角度进行分类。一种常见的分类方式是将它们分为以下几大类：
⚝ 基本数据类型（Fundamental Types）：也称为原始类型（Primitive Types），这些类型直接由 C++ 语言标准定义，不依赖于其他类型。它们是构建更复杂数据类型的基础。
⚝ 复合类型（Compound Types）：这些类型基于基本类型或其他复合类型构建，例如数组、引用、指针等。
⚝ 用户定义类型（User-defined Types）：这些类型由程序员使用类（Class）、结构体（Struct）、联合体（Union）、枚举（Enum）等机制定义。
理解这些分类有助于我们把握 C++ 类型系统的整体结构。本书的重点，整数类型，就属于最基础的“基本数据类型”。
1.2 基本数据类型（Fundamental Types）
C++ 的基本数据类型是语言内置的、最底层的数据表示形式。它们通常直接映射到计算机硬件的操作上，因此效率较高。C++ 标准定义了多种基本数据类型，主要包括：
① 整数类型（Integer Types）：用于表示整数值。这是本书的核心主题。
② 浮点类型（Floating-point Types）：用于表示带有小数部分的数值（实数），如 float、double、long double。它们以科学计数法或类似的方式在内存中表示，存在精度问题。
③ 字符类型（Character Types）：用于表示字符，如 char、wchar_t、char16_t、char32_t。它们本质上也是整数类型，因为字符通常通过其在特定字符集（如 ASCII、Unicode）中的编码值来表示。
④ 布尔类型（Boolean Type）：bool 类型，用于表示真（true）或假（false）这两种逻辑状态。
⑤ 空类型（Void Type）：void 类型，表示“没有类型”。它通常用于函数返回类型表示不返回任何值，或用于泛型指针 void*。void 类型没有关联的数值或操作。
⑥ 空指针类型（Null Pointer Type）：nullptr_t 类型，C++11 引入，用于表示空指针常量 nullptr 的类型。
在这些基本类型中，整数类型占据着核心地位。它们是数字计算、数据索引、内存寻址（通过指针算术）等许多底层操作的基础。
1.3 整数类型（Integer Types）在 C++ 中的核心地位
整数类型的重要性体现在 C++ 编程的方方面面：
⚝ 计数与循环控制：在循环（for, while）中，整数类型变量常被用作循环计数器或索引。
⚝ 数组与容器索引：访问数组（Array）或其他容器（如 std::vector, std::string）中的元素时，索引通常是整数类型。不正确地使用整数类型（尤其是涉及负数或无符号类型）可能导致越界访问。
⚝ 尺寸与偏移量表示：表示内存块的大小、对象的尺寸、数据偏移量等信息时，通常使用无符号整数类型，如 size_t。
⚝ 位操作与底层控制：在需要直接操作数据二进制位的场景（如硬件控制、数据压缩、加密算法）中，整数类型及其位运算符（Bitwise Operators）是必不可少的工具。
⚝ 系统编程与内存管理：在操作系统、驱动程序、嵌入式系统等领域，整数类型常用于处理地址、端口号、状态标志等底层信息。
⚝ 算法实现：许多基本算法，如排序、搜索、图遍历等，都大量依赖整数类型进行计数、比较和索引。
⚝ 性能敏感的代码：相比浮点运算，整数运算通常在现代处理器上更快、更精确（没有精度损失），因此在对性能要求高的场景中优先考虑使用整数。
⚝ 表示离散量：任何需要表示不可分割、可计数的事物（如人数、物品数量、错误码、枚举值）时，整数类型是自然的选择。
尽管整数类型如此基础且常用，但其具体的大小（位宽）、可表示范围、有符号（Signed）与无符号（Unsigned）的区别、溢出行为、不同类型之间的转换规则以及字面量的书写方式等细节，往往是初学者乃至有经验的开发者容易混淆或忽视的地方。这些细节处理不当，轻则导致程序行为异常，重则引发安全漏洞或难以追踪的 Bug。
深入理解 C++ 整数类型的这些细节，是写出健壮、高效、可移植 C++ 代码的关键一步。
1.4 本书目标与读者导引
本书的目标是提供一个关于 C++ 整数类型全面而深入的解析。我们将从最基本的概念出发，逐步深入到内存表示、运算规则、类型转换的复杂性，并探讨现代 C++ 标准（如 C++11, C++14）引入的相关特性。
本书旨在帮助读者达到以下目标：
⚝ 掌握基础：清晰理解各种标准整数类型的定义、修饰符及其基本用法。
⚝ 理解原理：深入了解整数在内存中的二进制表示（特别是二进制补码），以及类型大小和范围如何确定。
⚝ 熟练运用：掌握整数字面量的书写规则、各种整数运算符的使用，包括算术运算、位运算和比较运算。
⚝ 规避陷阱：识别并避免在使用整数类型时常见的错误，特别是有符号与无符号类型混合使用、溢出、类型转换中的问题。
⚝ 写出安全高效的代码：学会根据需求选择合适的整数类型，并利用标准库设施（如 <limits>, <cstdint>）编写更安全、可移植的代码。
⚝ 了解高级特性：熟悉固定宽度整数类型（如 int32_t, uint64_t）等现代 C++ 特性。
考虑到读者可能具有不同的 C++ 基础，本书的结构设计允许您根据自己的水平选择阅读的深度和重点：
⚝ 初学者（Beginners）：建议按章节顺序阅读，重点掌握 Chapter 2 (标准类型), Chapter 3 (大小与范围), Chapter 4 (字面量与初始化), Chapter 5 (基本运算) 和 Chapter 6 (基本类型转换) 的内容。理解有符号与无符号的区别，以及溢出的基本概念。
⚝ 中级开发者（Intermediate）：在掌握基础知识的基础上，应重点关注 Chapter 5 (运算细节，如溢出行为), Chapter 6 (类型转换的详细规则，特别是整型提升和算术转换), Chapter 7 (有符号与无符号交互的陷阱) 和 Chapter 8 (最佳实践)。这些章节将帮助您写出更健壮的代码。
⚝ 专家（Experts）：除了全面回顾前面章节的细节外，应特别关注 Chapter 3 (内存表示、跨平台问题), Chapter 7 (深入理解标准对有符号/无符号交互的定义), Chapter 9 (固定宽度整数、size_t、位字段、字节序) 和 Chapter 10 (C++ 标准演进中的相关特性)。这些内容有助于您理解底层机制、编写高性能代码以及进行系统级开发。
无论您的水平如何，我们鼓励您在阅读过程中动手实践书中的代码示例，并尝试修改和扩展它们，通过实践加深理解。🚀 让我们一起踏上 C++ 整数类型的深度探索之旅吧！
2. C++ 标准整数类型
本章将详细介绍 C++ 语言标准定义的基本整数类型（Integer Types）及其修饰符（Type Specifiers）。理解这些基本类型的定义、命名规则和用途是掌握 C++ 整数类型的基础。
2.1 有符号整数类型（Signed Integer Types）
有符号整数类型可以表示正数、负数和零。在 C++ 标准中，定义了一系列有符号整数类型，它们在内存中占用的空间大小通常是递增的，从而可以表示更大范围的数值。
① 标准有符号整数类型包括：
▮▮▮▮signed char
▮▮▮▮short int （通常简写为 short）
▮▮▮▮int
▮▮▮▮long int （通常简写为 long）
▮▮▮▮long long int （通常简写为 long long，自 C++11 起）
② 关于这些类型的说明：
▮▮▮▮signed char: 通常用于表示小范围的整数或 ASCII 字符集中的字符。它可以表示至少 \(-127\) 到 \(127\) 范围内的值。
▮▮▮▮short int: 简称 short。通常用于比 int 小的整数，以节省内存。它可以表示至少 \(-32767\) 到 \(32767\) 范围内的值。
▮▮▮▮int: 这是最常用的整数类型，通常是系统架构的“自然”字大小。它的具体大小依赖于实现（编译器和平台），但标准保证它可以表示至少 \(-32767\) 到 \(32767\) 范围内的值。
▮▮▮▮long int: 简称 long。用于需要比 int 更大范围的整数。标准保证 long 至少与 int 一样大，并且可以表示至少 \(-2147483647\) 到 \(2147483647\) 范围内的值。
▮▮▮▮long long int: 简称 long long。自 C++11 标准引入，用于需要更大范围的整数。标准保证 long long 至少与 long 一样大，并且可以表示至少 \(-9223372036854775807\) 到 \(9223372036854775807\) 范围内的值。它是 C++ 中保证的位宽最大的整数类型（至少 64 位）。
③ C++ 标准对这些类型的大小关系有如下保证：
▮▮▮▮sizeof(signed char) \( \le \) sizeof(short) \( \le \) sizeof(int) \( \le \) sizeof(long) \( \le \) sizeof(long long)
④ 示例代码：
1
#include <iostream>
2
3
int main() {
4
signed char sc = -10;
5
short s = 1000;
6
int i = -50000;
7
long l = 1000000;
8
long long ll = -9876543210LL; // 注意 long long 字面量后缀
9
10
std::cout << "signed char: " << (int)sc << std::endl; // 输出 char 时需要转换为 int 以显示数值
11
std::cout << "short: " << s << std::endl;
12
std::cout << "int: " << i << std::endl;
13
std::cout << "long: " << l << std::endl;
14
std::cout << "long long: " << ll << std::endl;
15
16
return 0;
17
}
注意：上述代码示例中，为了显示 signed char 的数值，将其强制转换（Cast）为了 int。这是因为 std::cout 在处理 char 类型时，通常会将其作为字符而非数值进行输出。
2.2 无符号整数类型（Unsigned Integer Types）
无符号整数类型只能表示非负数（零和正数）。与有符号类型相比，相同大小的无符号类型可以表示更大的正数范围，因为它们不使用最高位来表示符号。
① 标准无符号整数类型包括：
▮▮▮▮unsigned char
▮▮▮▮unsigned short int （通常简写为 unsigned short）
▮▮▮▮unsigned int （通常简写为 unsigned）
▮▮▮▮unsigned long int （通常简写为 unsigned long）
▮▮▮▮unsigned long long int （通常简写为 unsigned long long，自 C++11 起）
② 关于这些类型的说明：
▮▮▮▮这些无符号类型与对应的有符号类型占用相同的内存空间大小。
▮▮▮▮unsigned char: 通常用于表示原始字节数据（Raw Byte Data）或小范围的非负整数。它可以表示至少 \(0\) 到 \(255\) 范围内的值。
▮▮▮▮unsigned short int: 简称 unsigned short。可以表示至少 \(0\) 到 \(65535\) 范围内的值。
▮▮▮▮unsigned int: 简称 unsigned。它是最常用的无符号整数类型，通常用于计数、循环次数、位掩码（Bitmask）等场景。其范围依赖于实现，但至少能表示 \(0\) 到 \(65535\)。
▮▮▮▮unsigned long int: 简称 unsigned long。用于需要比 unsigned int 更大非负数范围的场景。至少能表示 \(0\) 到 \(4294967295\)。
▮▮▮▮unsigned long long int: 简称 unsigned long long。自 C++11 引入，用于需要极大非负数范围的场景。至少能表示 \(0\) 到 \(18446744073709551615\)。
③ 无符号整数类型特别适用于表示不会出现负值的量，例如：
▮▮▮▮内存地址（Memory Addresses）或大小（Size of Objects）
▮▮▮▮计数器（Counters）
▮▮▮▮位掩码（Bitmasks）或标志位（Flags）
④ 示例代码：
1
#include <iostream>
2
3
int main() {
4
unsigned char uc = 250;
5
unsigned short us = 60000;
6
unsigned int ui = 4000000000U; // 注意无符号字面量后缀 U
7
unsigned long ul = 5000000000UL; // 注意无符号 long 字面量后缀 UL
8
unsigned long long ull = 18000000000000000000ULL; // 注意无符号 long long 字面量后缀 ULL
9
10
std::cout << "unsigned char: " << (int)uc << std::endl; // 同样需要转换为 int 显示数值
11
std::cout << "unsigned short: " << us << std::endl;
12
std::cout << "unsigned int: " << ui << std::endl;
13
std::cout << "unsigned long: " << ul << std::endl;
14
std::cout << "unsigned long long: " << ull << std::endl;
15
16
return 0;
17
}
同样，为了显示 unsigned char 的数值，这里进行了强制类型转换。字面量后缀 U, UL, ULL 用于明确指定整数字面量是无符号类型。
2.3 类型修饰符（Type Specifiers）
在 C++ 中，可以使用一些关键词来修饰基本整数类型，以指定其有符号性或大小。这些关键词称为类型修饰符（Type Specifiers）。
① 主要的整数类型修饰符包括：
▮▮▮▮signed: 指示有符号类型。
▮▮▮▮unsigned: 指示无符号类型。
▮▮▮▮short: 指示短整数，通常占用比 int 小的内存。
▮▮▮▮long: 指示长整数，通常占用比 int 或 short 大的内存。
② 修饰符的组合规则：
▮▮▮▮signed 或 unsigned 可以与 char, short, int, long, long long 结合使用。
▮▮▮▮short 可以与 int 结合使用（例如 short int），也可以单独使用（例如 short，等同于 short int）。
▮▮▮▮long 可以与 int 结合使用（例如 long int），也可以单独使用（例如 long，等同于 long int）。
▮▮▮▮long long 只能与 int 结合使用（例如 long long int），也可以单独使用（例如 long long，等同于 long long int）。自 C++11 起引入。
▮▮▮▮如果 signed 或 unsigned 单独使用（例如 unsigned），它们默认修饰 int（等同于 unsigned int）。
▮▮▮▮对于 int, short, long, long long，如果没有显式使用 signed 或 unsigned 修饰，它们默认为有符号类型。例如，int 等同于 signed int，short 等同于 signed short int，long 等同于 signed long int，long long 等同于 signed long long int。
▮▮▮▮char 类型是特例，其有符号性是实现定义（Implementation-defined）的，详见下一节。
③ 常见的类型名称及其等价形式：
▮▮▮▮signed char
▮▮▮▮unsigned char
▮▮▮▮short 等同于 short int 等同于 signed short 等同于 signed short int
▮▮▮▮unsigned short 等同于 unsigned short int
▮▮▮▮int 等同于 signed 等同于 signed int
▮▮▮▮unsigned 等同于 unsigned int
▮▮▮▮long 等同于 long int 等同于 signed long 等同于 signed long int
▮▮▮▮unsigned long 等同于 unsigned long int
▮▮▮▮long long 等同于 long long int 等同于 signed long long 等同于 signed long long int (C++11+)
▮▮▮▮unsigned long long 等同于 unsigned long long int (C++11+)
④ 示例代码：
1
int main() {
2
short s1 = 10; // 等同于 signed short int s1 = 10;
3
signed short s2 = 20; // 等同于 short s2 = 20;
4
5
unsigned u1 = 100; // 等同于 unsigned int u1 = 100;
6
unsigned int u2 = 200; // 等同于 unsigned u2 = 200;
7
8
long l1 = 1000; // 等同于 signed long int l1 = 1000;
9
signed long l2 = 2000; // 等同于 long l2 = 2000;
10
11
// C++11 及以上
12
long long ll1 = 10000; // 等同于 signed long long int ll1 = 10000;
13
signed long long ll2 = 20000; // 等同于 long long ll2 = 20000;
14
15
return 0;
16
}
2.4 char 类型的特殊性
char 类型在 C++ 中具有一些特殊性，尤其是在其有符号性方面。
① char 类型的设计初衷是用于存储字符集中的成员，例如 ASCII 或 Unicode 的某个编码单元。然而，它也被归类为整数类型，因为字符在内存中通常以整数形式的编码值（Code Point）表示。
② char, signed char, 和 unsigned char 是三种不同的类型。
▮▮▮▮signed char 明确表示有符号整数，范围通常是 \(-128\) 到 \(127\)。
▮▮▮▮unsigned char 明确表示无符号整数，范围通常是 \(0\) 到 \(255\)。
▮▮▮▮char 类型的大小（sizeof(char)）保证是 1 字节。它的范围至少能够容纳基本字符集中的所有字符。然而，char 类型究竟是有符号（行为同 signed char）还是无符号（行为同 unsigned char）是实现定义（Implementation-defined）的。这意味着不同的编译器或不同的平台可能会将 char 默认实现为有符号或无符号。
③ 为什么 char 的有符号性是实现定义的？
▮▮▮▮这主要是为了允许编译器在权衡性能、兼容性等因素后，选择最适合目标平台的 char 实现。例如，某些处理器可能处理有符号字节更有效率，而另一些可能处理无符号字节更方便。
④ 这种实现定义的特性可能导致一些意外行为，尤其是在进行数值计算或与其他整数类型混合运算时。例如，如果 char 是有符号的，一个值 \(128\)（在 unsigned char 中是合法的）赋值给 char 可能导致溢出或变成负数。
⑤ 在需要处理原始字节数据（例如从文件或网络读取的数据）或者需要确保 \(0-255\) 范围内的数值时，为了代码的可移植性和避免依赖于 char 的默认实现，强烈推荐显式使用 signed char 或 unsigned char。
⑥ 示例代码：
1
#include <iostream>
2
#include <limits>
3
4
int main() {
5
char c = 'A';
6
unsigned char uc = 200;
7
signed char sc = -50;
8
9
std::cout << "char c: " << c << " (numerical value: " << (int)c << ")" << std::endl;
10
std::cout << "unsigned char uc: " << (int)uc << std::endl;
11
std::cout << "signed char sc: " << (int)sc << std::endl;
12
13
// 检查 char 的有符号性 (示例方法)
14
char test_char = std::numeric_limits<char>::max();
15
std::cout << "std::numeric_limits<char>::max() on this system: " << (int)test_char << std::endl;
16
17
// 如果 test_char 的值是 127，则 char 可能是 signed
18
// 如果 test_char 的值是 255，则 char 可能是 unsigned
19
// 注意：这并非100%准确的判断方法，但通常有效。
20
// 更准确的方式是查看编译器文档或使用预定义的宏（如__CHAR_UNSIGNED__）
21
// 但依赖于具体的编译器实现。
22
23
// 潜在的陷阱示例：假设 char 是 signed
24
char byte_value = 128; // 如果 char 最大值是 127，这里会发生问题
25
std::cout << "Assigning 128 to char: " << (int)byte_value << std::endl; // 可能输出 -128
26
27
unsigned char safe_byte_value = 128; // 使用 unsigned char 更安全
28
std::cout << "Assigning 128 to unsigned char: " << (int)safe_byte_value << std::endl; // 输出 128
29
30
return 0;
31
}
在这个例子中，将 128 赋值给 char byte_value 的行为是依赖于实现的。如果 char 是有符号的（例如在大多数 x86 系统上），并且其大小是 1 字节，那么 128 可能会被视为一个负数（通常是 \(-128\)，采用二进制补码表示）。而 unsigned char 可以正确地表示 \(128\)。这是使用 signed char 或 unsigned char 来明确意图的一个重要原因。
3. 整数类型的属性：大小、范围与表示
欢迎来到本书的第三章！在上一章，我们已经了解了 C++ 标准定义的各种整数类型及其修饰符。但是，了解一个类型的名称只是第一步。在实际编程中，尤其是在追求效率、控制内存布局或进行跨平台开发时，深入理解这些整数类型在内存中占据多大的空间、能表示哪些数值范围以及它们是如何在二进制层面被表示的，变得至关重要。本章将带领大家深入探索 C++ 整数类型的这些核心属性。
3.1 类型大小（Size of Types）与 sizeof 运算符
在 C++ 中，每一种数据类型都在内存中占用一定的空间。对于整数类型而言，这个空间的大小通常以字节（Byte）为单位衡量。了解一个类型的大小，对于内存分配、数据结构布局以及优化程序性能都非常有帮助。
C++ 提供了一个非常有用的运算符：sizeof。
⚝ sizeof 运算符（sizeof Operator）
sizeof 运算符用于获取类型或变量在内存中所占用的字节数。它的结果是一个无符号整数，类型通常是 size_t。size_t 类型定义在 <cstddef> 头文件中，它是一个无符号整数类型，其大小足以表示任何对象的大小。
sizeof 可以应用于：
⚝ 类型名称，例如 sizeof(int)。
⚝ 表达式，例如 sizeof(a + b)，此时 sizeof 会评估表达式的类型，但不会真正执行表达式的计算。
示例代码：使用 sizeof
1
#include <iostream>
2
#include <cstddef> // 包含 size_t 的定义
3
4
int main() {
5
std::cout << "各种整数类型的大小：" << std::endl;
6
std::cout << "sizeof(char): " << sizeof(char) << " bytes" << std::endl;
7
std::cout << "sizeof(signed char): " << sizeof(signed char) << " bytes" << std::endl;
8
std::cout << "sizeof(unsigned char): " << sizeof(unsigned char) << " bytes" << std::endl;
9
std::cout << "sizeof(short int): " << sizeof(short int) << " bytes" << std::endl;
10
std::cout << "sizeof(unsigned short int): " << sizeof(unsigned short int) << " bytes" << std::endl;
11
std::cout << "sizeof(int): " << sizeof(int) << " bytes" << std::endl;
12
std::cout << "sizeof(unsigned int): " << sizeof(unsigned int) << " bytes" << std::endl;
13
std::cout << "sizeof(long int): " << sizeof(long int) << " bytes" << std::endl;
14
std::cout << "sizeof(unsigned long int): " << sizeof(unsigned long int) << " bytes" << std::endl;
15
std::cout << "sizeof(long long int): " << sizeof(long long int) << " bytes" << std::endl;
16
std::cout << "sizeof(unsigned long long int): " << sizeof(unsigned long long int) << " bytes" << std::endl;
17
18
int my_var;
19
std::cout << "sizeof(my_var): " << sizeof(my_var) << " bytes" << std::endl; // 结果与 sizeof(int) 相同
20
21
return 0;
22
}
运行上述代码，你可能会看到类似以下的输出（具体数值取决于你的编译器和操作系统）：
1
各种整数类型的大小：
2
sizeof(char): 1 bytes
3
sizeof(signed char): 1 bytes
4
sizeof(unsigned char): 1 bytes
5
sizeof(short int): 2 bytes
6
sizeof(unsigned short int): 2 bytes
7
sizeof(int): 4 bytes
8
sizeof(unsigned int): 4 bytes
9
sizeof(long int): 8 bytes
10
sizeof(unsigned long int): 8 bytes
11
sizeof(long long int): 8 bytes
12
sizeof(unsigned long long int): 8 bytes
13
sizeof(my_var): 4 bytes
不同平台上的差异（Platform Differences）
一个重要的概念是，除了 char（被定义为 1 字节）和 long long（至少 8 字节）之外，C++ 标准没有强制规定 short, int, long 的确切大小。它只规定了它们之间的最小大小和相对大小关系：
① sizeof(char) 是 1。
② sizeof(short) \(\le\) sizeof(int) \(\le\) sizeof(long) \(\le\) sizeof(long long)。
③ short 至少有 16 位（2 字节）。
④ int 至少有 16 位（2 字节）。
⑤ long 至少有 32 位（4 字节）。
⑥ long long 至少有 64 位（8 字节）。
这意味着在不同的系统上：
⚝ 在一些 32 位系统上，int 和 long 可能都是 4 字节。
⚝ 在一些 64 位系统上，int 可能是 4 字节，而 long 和 long long 都是 8 字节。
⚝ 在一些嵌入式系统上，int 可能只有 2 字节。
了解这一点对于编写可移植（Portable）的代码非常重要。我们将在 3.3 节详细讨论可移植性问题。
3.2 数值范围（Value Range）
一个整数类型的大小（即它在内存中占用的位数）直接决定了它可以表示的数值范围。有符号（Signed）整数和无符号（Unsigned）整数在表示范围上有着根本的区别，这取决于它们如何解释最高位（Most Significant Bit, MSB）。
一个占用 \(N\) 位的整数类型总共可以表示 \(2^N\) 个不同的值。
3.2.1 有符号整数的范围与二进制补码（Two's Complement）表示
有符号整数类型（如 int, short, long）需要区分正数、负数和零。绝大多数现代计算机系统使用二进制补码（Two's Complement）来表示有符号整数。二进制补码有以下优点：
⚝ 唯一表示零（没有 +0 和 -0）。
⚝ 加法运算可以直接进行，无论操作数是正数还是负数。
⚝ 最高位作为符号位（Sign Bit）：0 表示非负数，1 表示负数。
对于一个 \(N\) 位的二进制补码表示的有符号整数：
⚝ 它能表示的最小值是 \( -(2^{N-1}) \)。
⚝ 它能表示的最大值是 \( 2^{N-1} - 1 \)。
⚝ 零的表示是全 0。
⚝ \( -1 \) 的表示是全 1。
如何计算二进制补码的数值：
对于一个 \(N\) 位的二进制数 \( b_{N-1} b_{N-2} \dots b_1 b_0 \)：
⚝ 如果 \(b_{N-1} = 0\)（非负数），其值为 \( \sum_{i=0}^{N-2} b_i \times 2^i \)。
⚝ 如果 \(b_{N-1} = 1\)（负数），其值为 \( -(2^{N-1}) + \sum_{i=0}^{N-2} b_i \times 2^i \)。
或者，另一种理解负数数值的方法是：对该负数的二进制补码取反（包括符号位），然后加 1，得到的结果是其绝对值的二进制表示。
示例：8 位有符号整数（signed char）
一个字节有 8 位，所以 \(N=8\)。
最高位是第 7 位（索引从 0 开始）。
最小值：\( -(2^{8-1}) = -(2^7) = -128 \)。
最大值：\( 2^{8-1} - 1 = 2^7 - 1 = 127 \)。
范围是 \([-128, 127]\)。
⚝ 示例：
▮▮▮▮ⓐ \(00000000_2\) 对应十进制 0。
▮▮▮▮ⓑ \(01111111_2\) 对应十进制 \(2^6 + 2^5 + \dots + 2^0 = 127\)。
▮▮▮▮ⓒ \(10000000_2\) 对应十进制 \( -(2^7) + 0 = -128 \)。
▮▮▮▮ⓓ \(11111111_2\) 对应十进制 \( -(2^7) + 2^6 + \dots + 2^0 = -128 + 127 = -1 \)。
注意： C++ 标准允许有符号整数使用二进制补码、原码（Sign-Magnitude）或反码（One's Complement）表示，但几乎所有现代平台都使用二进制补码。对于原码和反码，都存在两种方式表示零（+0 和 -0），且运算实现更复杂，因此在实际中很少见到。本 书假定读者所在的平台使用二进制补码表示有符号整数。
3.2.2 无符号整数的范围
无符号整数类型（如 unsigned int, unsigned short）不使用任何位来表示符号，所有的位都用于表示非负数值。
对于一个 \(N\) 位的无符号整数：
⚝ 它能表示的最小值是 \( 0 \)。
⚝ 它能表示的最大值是 \( 2^N - 1 \)。
⚝ 范围是 \([0, 2^N - 1]\)。
如何计算无符号整数的数值：
对于一个 \(N\) 位的二进制数 \( b_{N-1} b_{N-2} \dots b_1 b_0 \)，其值为 \( \sum_{i=0}^{N-1} b_i \times 2^i \)。
示例：8 位无符号整数（unsigned char）
一个字节有 8 位，所以 \(N=8\)。
最小值：\( 0 \)。
最大值：\( 2^8 - 1 = 256 - 1 = 255 \)。
范围是 \([0, 255]\)。
⚝ 示例：
▮▮▮▮ⓐ \(00000000_2\) 对应十进制 0。
▮▮▮▮ⓑ \(11111111_2\) 对应十进制 \(2^7 + 2^6 + \dots + 2^0 = 255\)。
总结不同位数的整数范围（使用二进制补码表示有符号数）：
| 位数 (N) | 字节数 | 有符号范围 | 无符号范围 | 常见类型 |
|---|---|---|---|---|
| 8 | 1 | \([-128, 127]\) | \([0, 255]\) | char, signed char, unsigned char |
| 16 | 2 | \([-32768, 32767]\) | \([0, 65535]\) | short, unsigned short |
| 32 | 4 | \([-2^{31}, 2^{31}-1]\) | \([0, 2^{32}-1]\) | int (常见), long (部分平台), unsigned int (常见), unsigned long (部分平台) |
| 64 | 8 | \([-2^{63}, 2^{63}-1]\) | \([0, 2^{64}-1]\) | long (常见), long long, unsigned long (常见), unsigned long long |
请注意，上表中的“常见类型”只是典型的大小，实际大小取决于编译器和平台。只有 char 是固定 8 位（1 字节），long long 至少 64 位。
3.3 跨平台的可移植性问题
正如 3.1 节和 3.2 节讨论的，C++ 标准对整数类型的大小和范围只给出了最小保证和相对关系，而不是精确的大小。这导致了一个重要的挑战：跨平台的可移植性（Portability）。
编写 C++ 程序时，如果代码依赖于特定整数类型具有精确的大小或范围，那么在不同的编译器、操作系统或硬件架构上编译和运行时，可能会出现问题。
常见问题示例：
① 依赖于 int 的大小： 假设你写了一个程序，其中使用了 int 来存储一个可能超过 32767 的数值。在 int 是 32 位的系统上，这没问题。但在 int 是 16 位的嵌入式系统上，这个数值将无法正确存储，导致溢出（Overflow）和错误的结果。
② 结构体内存布局： 如果你定义了一个结构体，其中包含多个整数成员，它们在内存中的总大小和对齐方式可能因编译器和平台对整数类型大小的处理不同而变化。这会影响与外部数据格式交互（如文件读写、网络通信）的兼容性。
③ 序列化/反序列化： 当你需要将内存中的整数数据按字节顺序写入文件或通过网络发送时，如果不知道确切的字节数和字节顺序（Endianness，参见 9.4 节），就无法保证在另一个平台上能正确读取和解析。
④ 位操作（Bit Manipulation）： 依赖于某个类型确切位宽的位操作（如设置或清除第 31 位）在不同位宽的类型上会表现不同。
如何提高可移植性：
⚝ 避免依赖特定大小： 尽量避免在代码中硬编码对 int 是 4 字节这样的假设。
⚝ 使用 sizeof 动态获取大小： 需要知道大小时，使用 sizeof 运算符。
⚝ 使用标准库提供的范围信息： 使用 <limits> 或 <climits> 获取类型的最大最小值，而不是硬编码魔术数字。
⚝ 使用固定宽度整数类型： C++11 引入了 <cstdint> 头文件，提供了保证大小的整数类型（如 int32_t, uint64_t）。这是解决可移植性问题的首选方法（将在第 9 章详细介绍）。
⚝ 文档说明： 对于必须依赖特定平台特性的代码，要清晰地在文档中说明其依赖性。
理解整数类型大小和范围的不确定性，并采取相应的编程策略，是编写健壮、可移植 C++ 代码的关键一步。
3.4 标准库中的范围信息：<limits> 和 <climits>
为了帮助程序员获取整数类型的属性信息，C++ 标准库提供了两种主要方式：
① <climits> 头文件： 这是 C 语言 <limits.h> 头文件在 C++ 中的版本。它通过宏（Macro）定义了各种基本整数类型的属性，例如：
⚝ CHAR_BIT: 一个字节中的位数（通常是 8）。
⚝ SCHAR_MIN, SCHAR_MAX: signed char 的最小值和最大值。
⚝ UCHAR_MAX: unsigned char 的最大值。
⚝ SHRT_MIN, SHRT_MAX: short 的最小值和最大值。
⚝ USHRT_MAX: unsigned short 的最大值。
⚝ INT_MIN, INT_MAX: int 的最小值和最大值。
⚝ UINT_MAX: unsigned int 的最大值。
⚝ LONG_MIN, LONG_MAX: long 的最小值和最大值。
⚝ ULONG_MAX: unsigned long 的最大值。
⚝ LLONG_MIN, LLONG_MAX: long long 的最小值和最大值。
⚝ ULLONG_MAX: unsigned long long 的最大值。
这些宏提供的值是编译时常量。
② <limits> 头文件： 这是 C++ 风格的获取类型属性的方式，通过 std::numeric_limits 模板类。它提供了更丰富的类型信息，不仅包括整数类型，还包括浮点类型，而且是以类模板的形式提供，更符合 C++ 的现代编程风格。
std::numeric_limits<T> 提供了各种静态成员函数和静态数据成员来查询类型 T 的属性，例如：
⚝ std::numeric_limits<T>::is_specialized: 如果对类型 T 有专门的实现，则为 true。
⚝ std::numeric_limits<T>::min(): 类型的最小值。对于浮点数是最小正规范化值，对于整数是真正的最小值。
⚝ std::numeric_limits<T>::max(): 类型的最大值。
⚝ std::numeric_limits<T>::lowest(): 类型的最低可表示值。对于整数与 min() 相同，对于浮点数可能是负无穷。
⚝ std::numeric_limits<T>::digits: 表示数值的位数（不包括符号位）。
⚝ std::numeric_limits<T>::digits10: 保证可以不失真地表示的十进制位数。
⚝ std::numeric_limits<T>::is_signed: 如果类型是有符号的，则为 true。
⚝ std::numeric_limits<T>::is_unsigned: 如果类型是无符号的，则为 true。
⚝ std::numeric_limits<T>::radix: 表示的进制（对于整数是 2）。
在现代 C++ 编程中，通常推荐使用 <limits>，因为它更通用、更安全（类型安全），并提供了更多信息。
示例代码：使用 <climits> 和 <limits>
1
#include <iostream>
2
#include <climits> // 引入 C 风格的限制宏
3
#include <limits> // 引入 C++ 风格的 numeric_limits
4
5
int main() {
6
std::cout << "使用 <climits> 获取 int 类型的范围：" << std::endl;
7
std::cout << "INT_MIN: " << INT_MIN << std::endl;
8
std::cout << "INT_MAX: " << INT_MAX << std::endl;
9
std::cout << "UINT_MAX: " << UINT_MAX << std::endl; // 注意：UINT_MAX 是 unsigned int 的最大值
10
11
std::cout << "\n使用 <limits> 获取 int 类型的范围和属性：" << std::endl;
12
std::cout << "std::numeric_limits<int>::is_specialized: "
13
<< std::boolalpha << std::numeric_limits<int>::is_specialized << std::endl;
14
std::cout << "std::numeric_limits<int>::min(): "
15
<< std::numeric_limits<int>::min() << std::endl;
16
std::cout << "std::numeric_limits<int>::max(): "
17
<< std::numeric_limits<int>::max() << std::endl;
18
std::cout << "std::numeric_limits<int>::digits: "
19
<< std::numeric_limits<int>::digits << std::endl; // 不含符号位的位数
20
std::cout << "std::numeric_limits<int>::digits10: "
21
<< std::numeric_limits<int>::digits10 << std::endl;
22
std::cout << "std::numeric_limits<int>::is_signed: "
23
<< std::boolalpha << std::numeric_limits<int>::is_signed << std::endl;
24
std::cout << "std::numeric_limits<int>::radix: "
25
<< std::numeric_limits<int>::radix << std::endl; // 通常是 2
26
27
std::cout << "\n使用 <limits> 获取 unsigned int 类型的范围和属性：" << std::endl;
28
std::cout << "std::numeric_limits<unsigned int>::min(): "
29
<< std::numeric_limits<unsigned int>::min() << std::endl;
30
std::cout << "std::numeric_limits<unsigned int>::max(): "
31
<< std::numeric_limits<unsigned int>::max() << std::endl;
32
std::cout << "std::numeric_limits<unsigned int>::is_signed: "
33
<< std::boolalpha << std::numeric_limits<unsigned int>::is_signed << std::endl;
34
std::cout << "std::numeric_limits<unsigned int>::is_unsigned: "
35
<< std::boolalpha << std::numeric_limits<unsigned int>::is_unsigned << std::endl;
36
37
return 0;
38
}
运行上述代码，你将能够看到你的系统上 int 和 unsigned int 的具体范围和一些属性。这些信息对于理解特定平台上的整数行为以及编写依赖于这些属性的代码（例如，范围检查）非常有价值。
本章我们深入探讨了 C++ 整数类型的大小、数值范围以及它们在内存中的二进制表示，特别是二进制补码。我们还讨论了这些属性在不同平台上的差异以及如何使用 sizeof、<climits> 和 <limits> 来查询这些信息。对这些基本属性的深刻理解，是掌握整数运算、类型转换以及避免常见陷阱的基础。
4. 整数的字面量（Literals）与初始化
欢迎来到本书的第四章！🚀 在前面的章节中，我们详细探讨了 C++ 中的各种整数类型、它们的大小、范围以及在内存中的表示。理解了这些基础知识后，接下来自然需要学习如何在我们的 C++ 代码中书写整数常量，以及如何将这些值赋给（或者说初始化）我们定义的整数变量。这就是本章的核心内容：整数字面量（Integer Literals）和整数变量的初始化。掌握这些内容，是编写清晰、准确、可靠的 C++ 代码的基础。
4.1 整数字面量的不同表示
在 C++ 中，整数字面量是直接出现在代码中的整数常量值。它们可以采用不同的进制表示，以满足不同的编程需求或提高代码的可读性。C++ 支持以下几种常见的进制表示：
4.1.1 十进制（Decimal）
这是我们日常生活中最常用的进制，也是代码中最常见的表示形式。十进制整数字面量由数字 0-9 组成，不能以 0 开头（除非值本身就是 0）。
示例：
1
int decimal_value_1 = 42;
2
int decimal_value_2 = 0;
3
// int invalid_decimal = 010; // 错误：以0开头的非零数会被认为是八进制
4.1.2 八进制（Octal）
八进制整数字面量由数字 0-7 组成，并以前缀 0 开头。
示例：
1
int octal_value_1 = 052; // 052 八进制 = 5*8^1 + 2*8^0 = 40 + 2 = 42 十进制
2
int octal_value_2 = 010; // 010 八进制 = 1*8^1 + 0*8^0 = 8 十进制
使用八进制通常是为了表示文件权限（在类 Unix 系统中常见）或其他需要按位操作的场景，尽管在现代 C++ 中，十六进制更为常用。
4.1.3 十六进制（Hexadecimal）
十六进制整数字面量由数字 0-9 和字母 a-f（或 A-F）组成，并以 0x 或 0X 作为前缀。每个十六进制位代表 4 个二进制位，这使得十六进制非常适合表示内存地址、颜色值或位掩码（Bitmasks）等与二进制表示紧密相关的值。
示例：
1
int hex_value_1 = 0x2A; // 0x2A 十六进制 = 2*16^1 + 10*16^0 = 32 + 10 = 42 十进制
2
int hex_value_2 = 0xFF; // 0xFF 十六进制 = 15*16^1 + 15*16^0 = 240 + 15 = 255 十进制
3
int hex_value_3 = 0xA3B; // 0xA3B 十六进制 = 10*16^2 + 3*16^1 + 11*16^0 = 2560 + 48 + 11 = 2619 十进制
4.1.4 二进制（Binary, C++14+）
从 C++14 标准开始，可以直接使用二进制整数字面量，前缀为 0b 或 0B，后跟 0 和 1。这极大地提高了在代码中直接表示位模式时的可读性。
示例（C++14 及更高版本）：
1
int binary_value_1 = 0b101010; // 0b101010 二进制 = 32 + 8 + 2 = 42 十进制
2
int binary_value_2 = 0b11111111; // 0b11111111 二进制 = 255 十进制
3
// int invalid_binary = 0b102; // 错误：二进制字面量只能包含 0 和 1
在 C++14 之前，如果需要在代码中表示二进制值，通常会使用十六进制或依赖特定的编译器扩展。
4.2 字面量的类型后缀（Suffixes）
默认情况下，整数字面量会根据其值和表示形式被编译器推断为特定的类型（我们将在下一节详细讨论）。但有时我们需要明确指定字面量的类型，这时就可以使用类型后缀（Type Suffixes）。
类型后缀紧跟在数字序列之后，用来指示字面量是无符号类型（Unsigned Type）、长整型（Long Integer）还是长长整型（Long Long Integer）。
⚝ 无符号后缀：u 或 U
⚝ 长整型后缀：l 或 L
⚝ 长长整型后缀：ll 或 LL
这些后缀可以单独使用，也可以组合使用（如 ul 或 LLU），但不超过三个后缀且顺序通常是先长短再有无符号（尽管有些组合是等价的）。
示例：
1
int a = 42; // 默认类型推断
2
unsigned int b = 42U; // 指定为无符号整型
3
long c = 42L; // 指定为长整型
4
unsigned long d = 42UL; // 指定为无符号长整型
5
long long e = 42LL; // 指定为长长整型
6
unsigned long long f = 42ULL; // 指定为无符号长长整型
7
8
// 十六进制和八进制字面量也可以使用后缀
9
int g = 0xFF;
10
unsigned int h = 0xFFU;
11
long long i = 0x2ALL;
12
13
// C++14+ 二进制字面量也可以使用后缀
14
unsigned char byte_mask = 0b11110000U;
15
long long large_binary = 0b10101010101010101010101010101010LL;
使用类型后缀的主要原因有：
① 确保字面量具有预期的类型，特别是在涉及类型匹配、函数重载或模板实例化时。
② 处理超出默认类型范围的值，例如一个很大的值，需要指定为 long long。
③ 提高代码可读性，明确表明字面量的意图类型。
4.3 整数字面量的默认类型推断
如果没有明确指定类型后缀，编译器会根据整数字面量的值及其表示形式（十进制、八进制、十六进制、二进制）自动推断其类型。推断规则如下：
① 对于十进制字面量：
▮▮▮▮编译器会尝试将其类型推断为 int、long int 或 long long int 中的第一个能容纳该值的类型。
▮▮▮▮例如：
▮▮▮▮▮▮▮▮42 的类型是 int。
▮▮▮▮▮▮▮▮2000000000 在许多 32 位系统上超出 int 范围，可能被推断为 long int。
▮▮▮▮▮▮▮▮一个非常大的值，如 9000000000000000000，超出 long int 范围，可能被推断为 long long int。
② 对于八进制、十六进制和二进制字面量：
▮▮▮▮编译器会尝试将其类型推断为以下列表中的第一个能容纳该值的类型：
▮▮▮▮▮▮▮▮int
▮▮▮▮▮▮▮▮unsigned int
▮▮▮▮▮▮▮▮long int
▮▮▮▮▮▮▮▮unsigned long int
▮▮▮▮▮▮▮▮long long int
▮▮▮▮▮▮▮▮unsigned long long int
▮▮▮▮例如：
▮▮▮▮▮▮▮▮0xFF 在许多系统上能容纳在 int 中，类型为 int。
▮▮▮▮▮▮▮▮0xFFFFFFFF 在 32 位系统上超出有符号 int 范围，但能容纳在 unsigned int 中，类型为 unsigned int。
▮▮▮▮▮▮▮▮0xFFFFFFFFFFFFFFFF 超出 64 位系统上的 long long int 范围，类型为 unsigned long long int。
重要提示： 这种默认类型推断规则有时可能会导致意想不到的结果，尤其是在与无符号类型交互或字面量接近类型最大值时。明确使用类型后缀可以消除这种不确定性，是推荐的做法之一。
4.4 数字分隔符（Digit Separators, C++14+）
长时间的数字序列，无论何种进制，都可能难以阅读。从 C++14 标准开始，你可以使用单引号 ' 作为数字分隔符来提高整数字面量的可读性。分隔符可以放置在数字序列中的任意位置（但不能是开头或结尾），通常用于分隔每三位或每四位，就像我们在书写大数字时使用的逗号或空格一样。
示例（C++14 及更高版本）：
1
long long large_number = 1'000'000'000LL; // 十进制
2
int hex_mask = 0xFF'FF'FF'FF; // 十六进制
3
int binary_flags = 0b1101'0010'1010'1100; // 二进制
4
int octal_perms = 0644; // 八进制也可以，尽管不常见
5
double pi = 3.141'592'653'589'793; // 浮点数字面量也可以使用分隔符
数字分隔符仅影响代码的可读性，不会改变字面量的值或类型。它们在编译时会被忽略。这是一个简单但非常实用的 C++14 特性，推荐在书写较长数字时使用。👍
4.5 整数变量的初始化
定义一个整数变量只是分配了内存空间，其中的值是不确定的（除非是全局或静态变量，它们会被零初始化）。为了使变量拥有一个明确的初始值，我们需要对其进行初始化（Initialization）。C++ 提供了多种初始化变量的方式。理解这些不同的初始化形式以及它们之间的细微差别对于避免潜在的错误至关重要。
我们将介绍 C++ 中常见的几种整数变量初始化方式：
4.5.1 值初始化（Value Initialization）
使用空括号 () 或空花括号 {} 进行初始化。对于基本类型，值初始化通常意味着初始化为零或等效的零值（例如，对于指针是 nullptr，对于布尔类型是 false）。
示例：
1
int a(); // 注意：这声明了一个函数，返回 int，而不是初始化一个变量！
2
int b{}; // C++11 标准引入的统一初始化语法，将 b 初始化为 0
传统的 int a(); 语法是函数声明，不是值初始化。应该使用 int b{}; 进行值初始化。
4.5.2 直接初始化（Direct Initialization）
使用小括号 () 包含一个或多个初始值。
示例：
1
int c(10); // 将 c 初始化为 10
4.5.3 拷贝初始化（Copy Initialization）
使用等号 = 后跟一个初始值。这是最常见的初始化形式。
示例：
1
int d = 20; // 将 d 初始化为 20
尽管语法上有等号，但这通常是一个初始化过程，而不是赋值操作。编译器在很多情况下会优化掉潜在的拷贝（称为拷贝省略 Copy Elision）。
4.5.4 列表初始化（List Initialization / Uniform Initialization）
使用花括号 {} 包含一个或多个初始值。这是 C++11 引入的一种通用初始化语法，旨在统一所有类型的初始化方式，并提供额外的安全性保证（尤其是针对窄化转换）。
示例：
1
int e{30}; // 将 e 初始化为 30
2
int f = {40}; // 将 f 初始化为 40，语法上与 {30} 类似，都是列表初始化
列表初始化的一个重要特性是它可以阻止窄化转换（Narrowing Conversion）。窄化转换是指将一个类型的值隐式转换为另一个类型，而该类型无法完全表示原始值（例如，将 long long 的大值赋给 int，或者将浮点值赋给整数）。如果使用列表初始化，并且初始值会导致窄化转换，编译器会报错。
示例（窄化转换）：
1
long long large_value = 10000000000LL;
2
int g = large_value; // 警告或错误：隐式窄化转换，值可能丢失
3
// int h{large_value}; // 编译错误：列表初始化阻止窄化转换
对于初学者和有经验的开发者来说，推荐优先使用列表初始化 {} 进行变量初始化。它不仅语法统一，更重要的是它提供了防止意外窄化转换的安全性，这可以帮助避免一些难以发现的错误。
总结一下本章： 我们学习了如何在代码中书写各种进制的整数字面量，如何使用类型后缀明确指定字面量的类型，理解了编译器默认的类型推断规则，以及如何使用数字分隔符提高代码可读性。最后，我们探讨了 C++ 中多种初始化整数变量的方式，并强调了列表初始化的优势。掌握字面量和初始化是正确使用整数类型的第一步，为后续章节深入学习整数运算和类型转换打下了坚实的基础。 💪
5. 整数运算（Integer Operations）
整数类型（Integer Types）是 C++ 中最基础也是最常用的数据类型之一。对整数进行运算是程序中不可或缺的部分。本章将详细解析 C++ 中针对整数的各种运算，包括算术运算、位运算、比较运算以及复合赋值运算。理解这些运算的规则，特别是其边界行为和潜在陷阱，对于编写正确、高效、可移植的 C++ 代码至关重要。
5.1 算术运算符（Arithmetic Operators）
C++ 提供了一系列标准的算术运算符，用于执行基本的数学计算。对于整数类型，这些运算符包括加（+）、减（-）、乘（*）、除（/）和取模（%）。
这些运算符的操作数（Operands）在执行运算前可能会经历整型提升（Integer Promotions）或算术转换（Arithmetic Conversions），以确保操作数具有合适的类型。例如，两个 short 类型的数相加，它们会先被提升到 int，然后再执行加法运算。
1
#include <iostream>
2
3
int main() {
4
int a = 10;
5
int b = 3;
6
7
std::cout << "加法 (Addition): " << a + b << std::endl; // 13
8
std::cout << "减法 (Subtraction): " << a - b << std::endl; // 7
9
std::cout << "乘法 (Multiplication): " << a * b << std::endl; // 30
10
11
// 除法和取模将在下一小节详细讨论
12
std::cout << "除法 (Division): " << a / b << std::endl; // 3 (整数除法)
13
std::cout << "取模 (Modulo): " << a % b << std::endl; // 1 (10 = 3 * 3 + 1)
14
15
int negative_a = -10;
16
std::cout << "负数加法: " << negative_a + b << std::endl; // -7
17
std::cout << "负数减法: " << negative_a - b << std::endl; // -13
18
std::cout << "负数乘法: " << negative_a * b << std::endl; // -30
19
20
return 0;
21
}
除了二元运算符（Binary Operators）外，加号和减号也可以用作一元运算符（Unary Operators），分别表示正号和负号。
1
#include <iostream>
2
3
int main() {
4
int x = 5;
5
int y = -x; // y becomes -5
6
int z = +x; // z becomes 5 (正号通常是多余的，但语法允许)
7
int negative_y = -y; // negative_y becomes 5
8
9
std::cout << "x: " << x << std::endl;
10
std::cout << "y (-x): " << y << std::endl;
11
std::cout << "z (+x): " << z << std::endl;
12
std::cout << "negative_y (-y): " << negative_y << std::endl;
13
14
return 0;
15
}
5.1.1 整数除法和取模（Integer Division and Modulo）
整数除法（/）和取模（%）是整数运算中需要特别注意的两个操作。
① 整数除法：
整数除法的结果是商的整数部分。C++11 标准规定，对于整数除法 /，结果会向零截断（Truncation Towards Zero）。这意味着无论操作数的符号如何，结果都总是朝着 0 的方向取整。
例如：
▮▮▮▮\( 10 / 3 = 3 \)
▮▮▮▮\( -10 / 3 = -3 \)
▮▮▮▮\( 10 / -3 = -3 \)
▮▮▮▮\( -10 / -3 = 3 \)
② 取模运算：
取模运算符 % 用于计算整数除法的余数。C++ 标准规定，对于整数 \( a \) 和 \( b \)（其中 \( b \neq 0 \)），表达式 \( (a / b) * b + (a \% b) \) 必须等于 \( a \)。基于整数除法向零截断的规则，这一定义决定了取模运算结果的符号规则：取模运算结果的符号与被除数（第一个操作数）的符号相同。
例如：
▮▮▮▮\( 10 \% 3 = 1 \) (因为 \( (10 / 3) * 3 + 1 = 3 * 3 + 1 = 10 \))
▮▮▮▮\( -10 \% 3 = -1 \) (因为 \( (-10 / 3) * 3 + (-1) = -3 * 3 + (-1) = -9 - 1 = -10 \))
▮▮▮▮\( 10 \% -3 = 1 \) (因为 \( (10 / -3) * -3 + 1 = -3 * -3 + 1 = 9 + 1 = 10 \))
▮▮▮▮\( -10 \% -3 = -1 \) (因为 \( (-10 / -3) * -3 + (-1) = 3 * -3 + (-1) = -9 - 1 = -10 \))
③ 除以零：
在 C++ 中，将整数除以零是未定义行为（Undefined Behavior）。这意味着编译器在这种情况下可以做任何事情，程序可能会崩溃，产生错误的结果，或者表现出其他不可预测的行为。在编写代码时必须避免这种情况。
1
#include <iostream>
2
3
int main() {
4
int a = 10;
5
int b = 3;
6
int neg_a = -10;
7
int neg_b = -3;
8
9
std::cout << "10 / 3 = " << a / b << ", 10 % 3 = " << a % b << std::endl;
10
std::cout << "-10 / 3 = " << neg_a / b << ", -10 % 3 = " << neg_a % b << std::endl;
11
std::cout << "10 / -3 = " << a / neg_b << ", 10 % -3 = " << a % neg_b << std::endl;
12
std::cout << "-10 / -3 = " << neg_a / neg_b << ", -10 % -3 = " << neg_a % neg_b << std::endl;
13
14
// int zero = 0;
15
// std::cout << "10 / 0 = " << a / zero << std::endl; // 未定义行为！
16
17
return 0;
18
}
5.1.2 算术溢出（Arithmetic Overflow）
算术溢出是指运算结果超出了目标类型所能表示的数值范围。C++ 中有符号整数（Signed Integers）和无符号整数（Unsigned Integers）在发生溢出时的行为是不同的。
① 无符号整数溢出：
对于无符号整数，溢出是定义好的行为，称为环绕行为（Wraparound Behavior）或模运算（Modulo Arithmetic）。当运算结果超出无符号类型的最大值时，它会“绕回”到该类型的最小值（通常是 0）。这相当于结果对 \( 2^N \) 取模，其中 \( N \) 是该无符号类型所占的位数。
例如，对于一个 8 位的无符号整数（最大值 255）：
▮▮▮▮\( 255 + 1 = 0 \)
▮▮▮▮\( 250 + 10 = 4 \) (因为 \( 260 \pmod{256} = 4 \))
1
#include <iostream>
2
#include <limits>
3
4
int main() {
5
unsigned int max_uint = std::numeric_limits<unsigned int>::max();
6
unsigned int result = max_uint + 1; // 溢出
7
8
std::cout << "Maximum unsigned int: " << max_uint << std::endl;
9
std::cout << "Maximum unsigned int + 1: " << result << std::endl; // 通常输出 0
10
11
unsigned char uchar_val = 250;
12
uchar_val = uchar_val + 10; // 250 + 10 = 260, 对于 unsigned char (8位), 260 % 256 = 4
13
std::cout << "unsigned char 250 + 10: " << (int)uchar_val << std::endl; // 输出 4 (注意这里转换为 int 打印以免再次环绕)
14
15
return 0;
16
}
② 有符号整数溢出：
对于有符号整数，溢出是未定义行为（Undefined Behavior）。这意味着标准没有规定在发生溢出时程序应该做什么。编译器可以假定溢出永远不会发生，并可能因此进行优化，导致在溢出真正发生时产生不可预测的结果。这可能是程序中一个非常危险的陷阱。
例如，对于一个 32 位的有符号整数（int），其最大值通常是 \( 2^{31} - 1 \approx 20 \times 10^8 \)。
如果 int a = std::numeric_limits<int>::max(); int result = a + 1;，则 result 的值是不确定的。它可能环绕到最小值（类似于无符号），可能保持最大值，可能引发硬件异常，或者产生其他任何结果。
1
#include <iostream>
2
#include <limits>
3
4
int main() {
5
int max_int = std::numeric_limits<int>::max();
6
// int result = max_int + 1; // 有符号整数溢出，未定义行为！
7
// std::cout << "Maximum int + 1: " << result << std::endl; // 结果不可预测
8
9
// 为了演示可能的环绕行为，我们可以先转换为无符号，加1，再转回有符号
10
// **但这只是演示，实际有符号溢出行为是未定义的**
11
unsigned int temp = static_cast<unsigned int>(max_int) + 1;
12
int potentially_wrapped_result = static_cast<int>(temp);
13
std::cout << "Maximum int: " << max_int << std::endl;
14
std::cout << "Potentially wrapped (demonstration): " << potentially_wrapped_result << std::endl; // 通常输出最小的负数
15
16
return 0;
17
}
避免有符号整数溢出的方法通常包括：
▮▮▮▮⚝ 使用足够大的整数类型（例如 long long）。
▮▮▮▮⚝ 在执行可能溢出的运算前，检查操作数是否会导致溢出。
▮▮▮▮⚝ 对于只需要非负值的场景，优先考虑无符号类型。
▮▮▮▮⚝ 启用编译器的警告，许多编译器可以检测到一些明显的溢出风险。
5.2 位运算符（Bitwise Operators）
位运算符直接操作整数的二进制位。它们通常用于低级编程、硬件控制、优化算法或处理标志位集合等场景。C++ 提供了六种位运算符：
⚝ 按位与（Bitwise AND）：&
⚝ 按位或（Bitwise OR）：|
⚝ 按位异或（Bitwise XOR）：^
⚝ 按位非（Bitwise NOT）：~
⚝ 左移（Left Shift）：<<
⚝ 右移（Right Shift）：>>
这些运算符在执行前也会进行整型提升（Integer Promotions）。通常，操作数会被提升到 int 或 unsigned int。按位非 ~ 是一个一元运算符，其他是二元运算符。
1
#include <iostream>
2
#include <iomanip> // 用于格式化输出 (十六进制)
3
4
int main() {
5
unsigned int a = 0b11001100; // C++14 二进制字面量 (十进制 204)
6
unsigned int b = 0b10101010; // 十进制 170
7
8
std::cout << "a (二进制): " << std::bitset<8>(a) << ", 十进制: " << a << std::endl;
9
std::cout << "b (二进制): " << std::bitset<8>(b) << ", 十进制: " << b << std::endl;
10
11
// 假设使用 8 位无符号整数进行演示
12
// 实际运算会先提升到 int 或 unsigned int (取决于平台和值), 位数可能更多
13
14
// 按位与 (&): 对应位都为 1 时结果为 1
15
// 11001100 & 10101010 = 10001000 (十进制 136)
16
std::cout << "a & b (二进制): " << std::bitset<8>(a & b) << ", 十进制: " << (a & b) << std::endl;
17
18
// 按位或 (|): 对应位至少一个为 1 时结果为 1
19
// 11001100 | 10101010 = 11101110 (十进制 238)
20
std::cout << "a | b (二进制): " << std::bitset<8>(a | b) << ", 十进制: " << (a | b) << std::endl;
21
22
// 按位异或 (^): 对应位不同时结果为 1
23
// 11001100 ^ 10101010 = 01100110 (十进制 102)
24
std::cout << "a ^ b (二进制): " << std::bitset<8>(a ^ b) << ", 十进制: " << (a ^ b) << std::endl;
25
26
// 按位非 (~): 对每一位取反
27
// ~a (假设 8 位): ~11001100 = 00110011 (十进制 51)
28
// 注意: 实际 ~a 的结果会是提升后的类型，例如 32 位 int，前面会是很多 1
29
// 为了演示 8 位取反，我们可以强制转换，但这可能导致信息丢失
30
unsigned char ua = 0b11001100;
31
std::cout << "~ua (二进制, 8位): " << std::bitset<8>(~ua) << ", 十进制: " << (int)(~ua) << std::endl;
32
33
34
// 移位运算将在下一小节详细讨论
35
unsigned int c = 10; // 二进制 00001010
36
std::cout << "c (十进制): " << c << ", 二进制: " << std::bitset<8>(c) << std::endl;
37
// 左移 (<<): 将位向左移动，右侧补 0
38
// 00001010 << 2 = 00101000 (十进制 40)
39
std::cout << "c << 2 (十进制): " << (c << 2) << ", 二进制: " << std::bitset<8>(c << 2) << std::endl;
40
// 右移 (>>): 将位向右移动
41
// 00001010 >> 1 = 00000101 (十进制 5)
42
std::cout << "c >> 1 (十进制): " << (c >> 1) << ", 二进制: " << std::bitset<8>(c >> 1) << std::endl;
43
44
45
return 0;
46
}
5.2.1 左移和右移的规则与未定义行为（Left and Right Shift Rules and Undefined Behavior）
位移运算符（<< 和 >>）用于将一个整数的所有二进制位向左或向右移动指定的位数。
① 左移 <<:
将操作数的二进制位向左移动指定的位数。空出的低位用零填充。
对于无符号操作数 val 和移位数 shift，结果是 \( val \times 2^{shift} \)，前提是结果能适应目标类型。
对于有符号操作数 val 和移位数 shift：
▮▮▮▮ⓐ 如果 val 是非负数，且结果能适应其类型，行为与无符号数类似，结果是 \( val \times 2^{shift} \)。
▮▮▮▮ⓑ 如果 val 是负数，左移的结果是未定义行为（Undefined Behavior）。
▮▮▮▮ⓒ 如果移位数 shift 是负数，或者大于或等于操作数的位数（例如，将一个 32 位的 int 左移 32 位或更多），结果是未定义行为。
② 右移 >>:```cpp
include
include
include
include
int main() {
unsigned int u_val = 0b10000000; // 128
signed int s_val = -128; // 假设 int 是 8 位，二进制补码表示为 10000000
// 左移 (<<)
std::cout << "左移 (Left Shift):" << std::endl;
// 无符号左移：空位补 0
// 0b10000000 << 1 = 0b00000000 (对于 8 位), 但通常提升到 int, 结果为 256
// 假设 int 32位，u_val 的 32位表示可能是 00..0010000000
// 左移 1 位变成 00..0100000000 (256)
std::cout << "unsigned " << u_val << " << 1 = " << (u_val << 1) << std::endl; // 256
// 有符号非负数左移
int s_pos = 64; // 二进制 01000000 (假设 8 位)
// 01000000 << 1 = 10000000 (-128 假设 8 位 int 补码), 结果可能溢出 int
// 假设 int 32位，s_pos 左移 1 位是 128
std::cout << "signed " << s_pos << " << 1 = " << (s_pos << 1) << std::endl; // 128
// 有符号负数左移：未定义行为
// std::cout << "signed " << s_val << " << 1 = " << (s_val << 1) << std::endl; // 未定义行为！
// 移位位数 >= 操作数位数：未定义行为
// int num_bits = std::numeric_limits
// std::cout << "signed " << s_pos << " << " << num_bits << " = " << (s_pos << num_bits) << std::endl; // 未定义行为！
std::cout << "\n右移 (Right Shift):" << std::endl;
// 无符号右移 (逻辑右移): 空位补 0
// 0b10000000 >> 1 = 0b01000000 (十进制 64)
std::cout << "unsigned " << u_val << " >> 1 = " << (u_val >> 1) << std::endl; // 64
// 有符号右移 (算术右移或逻辑右移，取决于实现，通常算术右移)
// 算术右移: 保持符号位 (高位补符号位)
// -128 (10000000 假设 8 位补码) >> 1
// 如果是算术右移: 10000000 >> 1 = 11000000 (-64 假设 8 位补码)
std::cout << "signed " << s_val << " >> 1 = " << (s_val >> 1) << std::endl; // 通常是 -64 (算术右移)
int s_pos2 = 127; // 二进制 01111111 (假设 8 位)
// 01111111 >> 1 = 00111111 (十进制 63)
std::cout << "signed " << s_pos2 << " >> 1 = " << (s_pos2 >> 1) << std::endl; // 63
// 移位位数 >= 操作数位数：未定义行为
// std::cout << "unsigned " << u_val << " >> " << num_bits << " = " << (u_val >> num_bits) << std::endl; // 未定义行为！
// std::cout << "signed " << s_val << " >> " << num_bits << " = " << (s_val >> num_bits) << std::endl; // 未定义行为！
// 移位位数为负数：未定义行为
// std::cout << "unsigned " << u_val << " >> -1 = " << (u_val >> -1) << std::endl; // 未定义行为！
return 0;
}
1
总结位移运算的未定义行为场景：
2
▮▮▮▮⚝ 左移一个负数。
3
▮▮▮▮⚝ 左移或右移的位数是一个负数。
4
▮▮▮▮⚝ 左移或右移的位数大于或等于被移位数的二进制位数。
5
▮▮▮▮⚝ 左移导致有符号数溢出（结果值超出了目标类型所能表示的范围）。
6
7
应尽量避免这些未定义行为，尤其是有符号数的左移和移位位数检查是重要的编程实践。对于无符号数，移位位数的限制同样适用。
8
9
### 5.3 比较运算符（Comparison Operators）
10
11
比较运算符（也称为关系运算符）用于比较两个值的大小或是否相等，结果是布尔类型（`bool`），值为 `true` 或 `false`。对于整数类型，C++ 提供了以下比较运算符：
12
⚝ 等于：`==`
13
⚝ 不等于：`!=`
14
⚝ 大于：`>`
15
⚝ 小于：`<`
16
⚝ 大于等于：`>=`
17
⚝ 小于等于：`<=`
18
19
在比较不同类型的整数时，可能会发生隐式类型转换（Implicit Type Conversion），特别是算术转换（Arithmetic Conversions）。通常，较窄的类型会被提升或转换为较宽的类型，或者有符号类型可能会转换为无符号类型（这一点在第 7 章会详细讨论其潜在陷阱）。理解这些转换规则对于正确判断比较结果至关重要。
20
21
```cpp
22
23
#include <iostream>
24
25
int main() {
26
int a = 10;
27
int b = 20;
28
int c = 10;
29
30
std::cout << "a == b: " << (a == b) << std::endl; // false (0)
31
std::cout << "a != b: " << (a != b) << std::endl; // true (1)
32
std::cout << "a > b: " << (a > b) << std::endl; // false (0)
33
std::cout << "a < b: " << (a < b) << std::endl; // true (1)
34
std::cout << "a >= c: " << (a >= c) << std::endl; // true (1)
35
std::cout << "a <= b: " << (a <= b) << std::endl; // true (1)
36
37
unsigned int ua = 10;
38
int sa = -1;
39
// 有符号与无符号比较的复杂性将在第 7 章深入探讨
40
// 简单来说，sa (-1) 会被转换为无符号类型，其无符号表示是一个非常大的正数
41
std::cout << "unsigned 10 > signed -1: " << (ua > sa) << std::endl; // 通常是 false (0)，因为 -1 转换为无符号是一个大正数
42
43
return 0;
44
}
上面的例子展示了基本比较，但需要注意有符号和无符号数比较时的隐式转换规则，这常常导致初学者犯错。
5.4 复合赋值运算符（Compound Assignment Operators）
复合赋值运算符提供了算术或位运算与赋值操作的结合。它们是 op= 的形式，其中 op 是一个二元运算符。例如，a += b 等价于 a = a + b，但通常只计算一次 a 的地址。对于整数类型，常见的复合赋值运算符包括：
⚝ +=：加并赋值
⚝ -=：减并赋值
⚝ *=：乘并赋值
⚝ /=：除并赋值
⚝ %=：取模并赋值
⚝ &=：按位与并赋值
⚝ |=：按位或并赋值
⚝ ^=：按位异或并赋值
⚝ <<=：左移并赋值
⚝ >>=：右移并赋值
这些运算符的行为与对应的二元运算符相同，只是结果直接赋回给左操作数。左操作数必须是一个可修改的左值（Modifiable Lvalue）。
1
#include <iostream>
2
3
int main() {
4
int a = 10;
5
int b = 5;
6
7
a += b; // 等价于 a = a + b; a 现在是 15
8
std::cout << "a after a += b: " << a << std::endl;
9
10
a -= b; // 等价于 a = a - b; a 现在是 10
11
std::cout << "a after a -= b: " << a << std::endl;
12
13
a *= b; // 等价于 a = a * b; a 现在是 50
14
std::cout << "a after a *= b: " << a << std::endl;
15
16
a /= b; // 等价于 a = a / b; a 现在是 10
17
std::cout << "a after a /= b: " << a << std::endl;
18
19
a %= b; // 等价于 a = a % b; a 现在是 0
20
std::cout << "a after a %= b: " << a << std::endl;
21
22
unsigned int u_val = 0b1100; // 12
23
unsigned int mask = 0b1010; // 10
24
25
u_val &= mask; // 等价于 u_val = u_val & mask; 0b1100 & 0b1010 = 0b1000 (8)
26
std::cout << "u_val after u_val &= mask (binary 1000): " << u_val << std::endl;
27
28
u_val |= mask; // 等价于 u_val = u_val | mask; 0b1000 | 0b1010 = 0b1010 (10)
29
std::cout << "u_val after u_val |= mask (binary 1010): " << u_val << std::endl;
30
31
u_val ^= mask; // 等价于 u_val = u_val ^ mask; 0b1010 ^ 0b1010 = 0b0000 (0)
32
std::cout << "u_val after u_val ^= mask (binary 0000): " << u_val << std::endl;
33
34
int shift_val = 10; // 二进制 00001010
35
shift_val <<= 2; // 等价于 shift_val = shift_val << 2; 00101000 (40)
36
std::cout << "shift_val after shift_val <<= 2: " << shift_val << std::endl;
37
38
shift_val >>= 3; // 等价于 shift_val = shift_val >> 3; 00000101 (5)
39
std::cout << "shift_val after shift_val >>= 3: " << shift_val << std::endl;
40
41
return 0;
42
}
好的，各位同学，我们将深入探讨 C++ 中一个既基础又充满细节的话题：整数类型转换。理解类型转换的规则，对于编写健壮、高效且没有意外行为的 C++ 代码至关重要。本章将带领大家全面掌握整数类型转换的原理、规则以及常见的陷阱。
6. 整数类型转换
本章深入解析 C++ 中整数类型之间的隐式和显式转换规则。理解这些规则能帮助你预测代码行为，避免潜在错误，特别是在处理不同大小或有符号/无符号的整数时。
6.1 隐式类型转换（Implicit Type Conversion）
隐式类型转换，顾名思义，是编译器在特定情况下自动进行的类型转换。在 C++ 中，隐式转换发生在多种场景下，例如：
⚝ 在表达式中，当操作数的类型不匹配时。
⚝ 将一个表达式的结果赋值给一个不同类型的变量时。
⚝ 将实参传递给形参时。
⚝ 从一个函数返回一个值时。
⚝ 初始化时。
对于整数类型而言，最重要的隐式转换规则包括整型提升（Integer Promotions）和算术转换（Arithmetic Conversions），它们主要发生在算术和位运算中。此外，还有其他一些隐式转换场景，比如转换为 bool 类型（非零值为 true，零值为 false）。
理解隐式转换非常重要，因为它们可能在你不经意间改变数值或其解释方式，导致非预期的结果或 bug。
6.2 整型提升（Integer Promotions）规则
整型提升是隐式转换的一种特殊形式，发生在某些小型整数类型（例如 char, short）参与表达式运算之前。其核心思想是将这些小型类型的值提升到至少能容纳其所有可能值的较大整数类型，通常是 int 或 unsigned int。这主要是为了与大多数 CPU 体系结构的原生字大小（通常对应 int）的操作效率保持一致。
整型提升的具体规则如下：
① 以下类型的右值（rvalue）可以被提升：
▮▮▮▮ⓑ signed char 或 signed short int。
▮▮▮▮ⓒ unsigned char 或 unsigned short int。
▮▮▮▮ⓓ 任何枚举类型（enumeration type）。
▮▮▮▮ⓔ 位字段（bit-field）。
▮▮▮▮ⓕ bool 类型。
② 提升的目标类型：
▮▮▮▮ⓑ 如果一个 int 可以完整地表示原始类型的所有值，那么该值被提升为 int。
▮▮▮▮ⓒ 否则，该值被提升为 unsigned int。
这个规则意味着，char (无论是 signed char, unsigned char, 还是普通的 char 其有无符号取决于实现)、signed char, unsigned char, short int, unsigned short int 以及枚举类型和 bool，在作为右值参与表达式运算时，通常都会被提升为 int，除非 int 的范围不足以表示 unsigned short int 等类型的所有值（这种情况比较罕见，通常发生在 int 和 short 大小相同的情况下），此时会提升为 unsigned int。
请看下面的示例：
1
#include <iostream>
2
#include <typeinfo>
3
4
int main() {
5
short s = 10;
6
char c = 'a';
7
unsigned short us = 65500; // 假设 unsigned short 是 16 位
8
9
auto result1 = s + 1;
10
auto result2 = c + 1;
11
auto result3 = us + 100;
12
13
std::cout << "type of s + 1: " << typeid(result1).name() << std::endl;
14
std::cout << "type of c + 1: " << typeid(result2).name() << std::endl;
15
std::cout << "type of us + 100: " << typeid(result3).name() << std::endl;
16
17
// 示例：有符号 char
18
signed char sc = -5;
19
auto result4 = sc + 1;
20
std::cout << "type of sc + 1: " << typeid(result4).name() << std::endl;
21
22
return 0;
23
}
在大多数平台上，short 和 char 的范围都小于 int，所以它们会提升为 int。unsigned short 通常也是 16 位，如果 int 是 32 位，那么 int 可以容纳 unsigned short 的所有值，所以 unsigned short 也会提升为 int。在上面的例子中，result1, result2, result3, result4 的类型在大多数情况下都会是 int。
注意：整型提升是发生在类型参与运算之前的。原始变量本身的类型并未改变。
整型提升是理解后续算术转换的基础。
6.3 算术转换（Arithmetic Conversions）
算术转换发生在当一个二元运算符（Binary Operator），如 +, -, *, /, %, &, |, ^, ==, !=, <, >, <=, >= 的操作数具有不同类型时。编译器会尝试将这些操作数转换为一个公共类型（Common Type），然后在这个公共类型上执行操作。这个过程遵循一套被称为“常用算术转换”（Usual Arithmetic Conversions）的复杂规则。
常用算术转换的目的是找到一个能够容纳所有操作数类型的值的“最宽”类型，并在该类型上进行运算。规则是分步进行的，大致遵循从宽到窄、从浮点到整数的优先级顺序。对于整数类型而言，发生在浮点转换规则之后，具体步骤如下（简化版，重点关注整数）：
① 步骤 1：浮点类型的转换（如果存在）
▮▮▮▮ⓑ 如果任一操作数的类型是 long double，另一个操作数被转换为 long double。
▮▮▮▮ⓒ 否则，如果任一操作数的类型是 double，另一个操作数被转换为 double。
▮▮▮▮ⓓ 否则，如果任一操作数的类型是 float，另一个操作数被转换为 float。
(如果操作数中包含浮点类型，则在这一步之后转换完成，结果是浮点类型。如果两个操作数都是整数类型，则进入下一步。)
② 步骤 2：整型提升（Integer Promotions）
▮▮▮▮ⓑ 对两个操作数都进行整型提升（如 6.2 节所述）。此时，操作数的类型至少是 int 或 unsigned int。
③ 步骤 3：处理提升后的类型
▮▮▮▮ⓑ 如果提升后的两个操作数类型相同，则无需进一步转换。
▮▮▮▮ⓒ 如果提升后的操作数类型不同，并且一个操作数是无符号类型，另一个是有符号类型：
▮▮▮▮▮▮▮▮❹ 如果无符号类型的级别（rank）高于有符号类型（例如 unsigned int vs int，但 unsigned long vs int），则有符号操作数被转换为无符号类型。
▮▮▮▮▮▮▮▮❺ 如果有符号类型可以表示无符号类型的所有值，并且有符号类型的级别高于或等于无符号类型（例如 long long vs unsigned int），则无符号操作数被转换为有符号类型。
▮▮▮▮▮▮▮▮❻ 否则（通常是当有符号类型不能表示无符号类型的所有值，且级别不低于无符号类型，例如 int vs unsigned int），两个操作数都被转换为与无符号操作数对应的无符号类型。这意味着有符号数会被转换为无符号数。
④ 步骤 4：处理提升后的类型（续）
▮▮▮▮ⓑ 如果步骤 3(b) 未发生（即两个操作数都是有符号或都是无符号），并且类型不同：
▮▮▮▮▮▮▮▮❸ 级别较低的操作数类型被转换为级别较高的操作数类型。例如，long 和 int 相加，int 被转换为 long。
整数类型的级别（Rank）通常按照其大小和有无符号性确定。一般来说，long long > long > int > short > char。无符号类型通常被认为与对应的有符号类型具有相同的级别。
最容易出错的情况是步骤 3(b)③，即有符号类型和无符号类型混合运算，并且无符号类型的级别不低于有符号类型。此时，有符号操作数会被强制转换为无符号类型。
示例分析：
1
#include <iostream>
2
3
int main() {
4
int a = -10;
5
unsigned int b = 5;
6
long c = 20;
7
unsigned long d = 30;
8
short s = 5; // 会被提升
9
10
// 示例 1: int 和 unsigned int 相加
11
// int(-10) + unsigned int(5)
12
// 步骤 2: 均已是 int/unsigned int，跳过提升
13
// 步骤 3: 有符号和无符号，且级别相同 (int vs unsigned int) -> 转换为 unsigned int
14
// -10 的 unsigned int 表示是一个很大的正数 (取决于 int 的位宽，例如 2^32 - 10)
15
// 表达式: unsigned int(非常大的数) + unsigned int(5)
16
auto result1 = a + b;
17
std::cout << "a + b = " << result1 << std::endl; // 输出一个很大的无符号数
18
19
// 示例 2: int 和 long 相加
20
// int(-10) + long(20)
21
// 步骤 2: int 和 long 已经满足最小位宽要求，跳过提升
22
// 步骤 3: 均有符号，跳过
23
// 步骤 4: 类型不同，long 的级别高于 int -> int 转换为 long
24
// 表达式: long(-10) + long(20)
25
auto result2 = a + c;
26
std::cout << "a + c = " << result2 << std::endl; // 输出 10
27
28
// 示例 3: long 和 unsigned int 相加
29
// long(20) + unsigned int(5)
30
// 步骤 2: 跳过提升
31
// 步骤 3: 有符号和无符号
32
// unsigned int 的级别低于 long
33
// long 类型可以表示 unsigned int 的所有值 (假设 long >= 32位)
34
// 步骤 3(b)②: unsigned int 转换为 long
35
// 表达式: long(20) + long(5)
36
auto result3 = c + b;
37
std::cout << "c + b = " << result3 << std::endl; // 输出 25
38
39
// 示例 4: unsigned long 和 int 相加
40
// unsigned long(30) + int(-10)
41
// 步骤 2: 跳过提升
42
// 步骤 3: 有符号和无符号
43
// unsigned long 的级别高于 int
44
// 步骤 3(b)①: int 转换为 unsigned long
45
// 表达式: unsigned long(30) + unsigned long(非常大的数)
46
auto result4 = d + a;
47
std::cout << "d + a = " << result4 << std::endl; // 输出 unsigned long(30 + 非常大的数)
48
49
// 示例 5: short 和 int 相加
50
// short(5) + int(-10)
51
// 步骤 2: short 提升为 int
52
// 表达式: int(5) + int(-10)
53
// 步骤 3/4: 类型相同，无需转换
54
auto result5 = s + a;
55
std::cout << "s + a = " << result5 << std::endl; // 输出 -5
56
57
return 0;
58
}
这些规则，特别是涉及到有符号和无符号类型混合运算时，是 C++ 中常见的 bug 源。当有符号数被转换为无符号数时，其值会发生巨大的变化（取模 \(2^N\)，其中 \(N\) 是无符号类型的位宽），导致非预期的结果。
6.4 显式类型转换（Explicit Type Conversion）/ 强制类型转换（Casts）
与隐式转换不同，显式类型转换是程序员通过特定的语法明确指定的类型转换。在 C++ 中，有两种主要的显式转换风格：C 风格和 C++ 风格。
① C 风格强制类型转换（C-style Cast）
语法形式为 (type) expression 或 type (expression)。
例如：
1
int x = 10;
2
double d = (double)x; // C 风格
3
int y = int(3.14); // C 风格，函数式语法
C 风格的强制类型转换语法简洁，但功能比较模糊，它可以执行多种类型的转换（如 static_cast, reinterpret_cast, const_cast 的组合）。这使得代码的可读性下降，且难以在代码中查找和区分不同目的的转换。因此，在 C++ 编程中，通常推荐使用 C++ 风格的强制类型转换。
② C++ 风格强制类型转换（C++-style Casts）
C++ 提供了四个关键字用于显式类型转换，每个关键字都有其特定的用途和限制，提高了代码的可读性和安全性：
▮▮▮▮ⓐ static_cast<目标类型>(表达式): 用于执行相对安全的、静态已知的转换。对于整数类型转换，它是最常用的工具。
▮▮▮▮▮▮▮▮❷ 用于基本类型之间的转换，如 int 到 double，double 到 int，int 到 short，unsigned int 到 int 等。
▮▮▮▮▮▮▮▮❸ 在整数类型之间进行转换时，static_cast 会遵循明确定义的规则：
▮▮▮▮▮▮▮▮▮▮▮▮从较宽的整数类型转换为较窄的整数类型（有符号或无符号）：发生截断（Truncation）。高位的比特被丢弃。
▮▮▮▮▮▮▮▮▮▮▮▮从较窄的有符号整数类型转换为较宽的整数类型：发生符号扩展（Sign Extension）。
▮▮▮▮▮▮▮▮▮▮▮▮从较窄的无符号整数类型转换为较宽的整数类型：发生零扩展（Zero Extension）。
▮▮▮▮▮▮▮▮▮▮▮▮有符号类型转换为无符号类型：保留值，但如果原值为负，则结果是原始值加上 \(2^N\) 的倍数，其中 \(N\) 是无符号类型的位宽（即按位表示不变，但解释方式改变）。
▮▮▮▮▮▮▮▮▮▮▮▮无符号类型转换为有符号类型：如果无符号值在有符号类型的范围内，则值为原值。如果无符号值超出范围，结果是实现定义的（Implementation-defined）或导致陷阱（trap）。
▮▮▮▮ⓑ reinterpret_cast<目标类型>(表达式): 用于执行低级别的、通常是不安全的位模式重解释。例如，将一个整数解释为一个指针，或者将一个指针解释为一个整数。在整数类型之间直接转换的场景中，static_cast 通常就足够了，reinterpret_cast 很少用于此目的，除非你确实想进行一些底层的位模式操作，但这通常是危险且不可移植的。
▮▮▮▮ⓒ const_cast<目标类型>(表达式): 用于添加或移除表达式的 const 或 volatile 属性。与整数类型的值转换无关。
▮▮▮▮ⓓ dynamic_cast<目标类型>(表达式): 主要用于运行时识别多态类对象的类型。与整数类型转换无关。
因此，在进行整数类型之间的显式转换时，你应该优先考虑使用 static_cast。
示例：使用 static_cast 进行整数转换
1
#include <iostream>
2
#include <cstdint> // For fixed-width integers
3
4
int main() {
5
int large_int = 1000;
6
short s = static_cast<short>(large_int); // int -> short (可能截断)
7
std::cout << "large_int (1000) static_cast to short: " << s << std::endl; // 输出 1000 (如果 short 足够大)
8
9
int neg_int = -5;
10
unsigned int ui = static_cast<unsigned int>(neg_int); // signed int -> unsigned int
11
std::cout << "neg_int (-5) static_cast to unsigned int: " << ui << std::endl; // 输出非常大的无符号数
12
13
unsigned int large_uint = 4000000000; // 假设 int 是 32 位
14
int i = static_cast<int>(large_uint); // unsigned int -> signed int (超出范围，实现定义)
15
std::cout << "large_uint (4000000000) static_cast to int: " << i << std::endl; // 输出实现定义的值
16
17
std::int8_t val_8bit = -10;
18
int val_int = static_cast<int>(val_8bit); // signed char -> int (符号扩展)
19
std::cout << "val_8bit (-10) static_cast to int: " << val_int << std::endl; // 输出 -10
20
21
unsigned short us = 65000; // 假设 unsigned short 是 16 位
22
unsigned int ui2 = static_cast<unsigned int>(us); // unsigned short -> unsigned int (零扩展)
23
std::cout << "us (65000) static_cast to unsigned int: " << ui2 << std::endl; // 输出 65000
24
25
return 0;
26
}
显式转换提供了更强的控制，但也要求程序员清楚转换可能带来的影响，尤其是截断和改变值的解释方式。
6.5 转换中的截断（Truncation）与符号扩展（Sign Extension）
在整数类型转换，尤其是大小不同或有无符号性不同的类型之间转换时，会涉及数据的位表示如何调整。主要的机制是截断、符号扩展和零扩展。
① 截断（Truncation）
当一个值被转换为一个位宽小于原类型的类型时，就会发生截断。简单来说，就是丢弃原值的高位比特，只保留低位比特。
无论原值是有符号还是无符号，截断的行为都是一样的：保留低 \(N\) 位（\(N\) 是目标类型的位宽），丢弃高于 \(N\) 位的比特。
示例：
假设 int 是 32 位，short 是 16 位。
一个 int 值 65537 (二进制: ...0000 0001 0000 0000 0000 0001) 转换为 short：
1
int large_val = 65537;
2
short s = static_cast<short>(large_val);
3
// large_val 的二进制 (低 16 位): 0000 0000 0000 0001
4
// 截断后 short 的值 (0000 0000 0000 0001) -> 1
5
std::cout << s << std::endl; // 输出 1
一个 int 值 -1 (二进制补码: 1111...1111 1111 1111 1111 1111) 转换为 unsigned short (16 位)：
1
int neg_val = -1;
2
unsigned short us = static_cast<unsigned short>(neg_val);
3
// neg_val 的二进制 (低 16 位): 1111 1111 1111 1111
4
// 截断后 unsigned short 的值 (1111 1111 1111 1111) -> 65535
5
std::cout << us << std::endl; // 输出 65535
截断会导致信息丢失，可能改变数值的大小和符号。
② 符号扩展（Sign Extension）
当一个有符号整数类型被转换为一个位宽更大的有符号或无符号类型时，会发生符号扩展。为了保留原始值的符号和数值，原类型的符号位（最高位）会被复制到新类型的高位比特中填充。
示例：
假设 signed char 是 8 位，int 是 32 位。
一个 signed char 值 -10 (二进制补码: 1111 0110) 转换为 int：
1
signed char sc = -10; // 二进制: 1111 0110
2
int i = static_cast<int>(sc);
3
// 符号位是 1，扩展时用 1 填充高位
4
// 结果 int 二进制: 1111...1111 1111 0110 (32位补码)
5
// 对应十进制值 -10
6
std::cout << i << std::endl; // 输出 -10
如果转换为无符号类型，先进行符号扩展，然后再将这个（较大的）有符号值转换为无符号类型。
③ 零扩展（Zero Extension）
当一个无符号整数类型被转换为一个位宽更大的有符号或无符号类型时，会发生零扩展。新类型的高位比特会用零填充。
示例：
假设 unsigned char 是 8 位，int 是 32 位。
一个 unsigned char 值 250 (二进制: 1111 1010) 转换为 int：
1
unsigned char uc = 250; // 二进制: 1111 1010
2
int i = static_cast<int>(uc);
3
// 高位用 0 填充
4
// 结果 int 二进制: 0000...0000 1111 1010 (32位)
5
// 对应十进制值 250
6
std::cout << i << std::endl; // 输出 250
请注意，如果将一个无符号类型转换为一个更宽的有符号类型，并且无符号值超出了目标有符号类型的最大正值，结果是实现定义的。但这很少见，因为通常情况下 int 比 unsigned short 宽，long 比 unsigned int 宽等等。
④ 同位宽有符号与无符号转换
将一个有符号类型转换为相同位宽的无符号类型，或反之，是一种位模式的重新解释。
⚝ 有符号转换为无符号：如果原值为非负，数值不变。如果原值为负，则结果是原值加上 \(2^N\)（\(N\) 是位宽）。这本质上是将二进制补码模式解释为无符号整数。
⚝ 无符号转换为有符号：如果无符号值在目标有符号类型的范围内（即小于等于其最大正值），则数值不变。如果无符号值超出范围（即大于目标有符号类型的最大正值），结果是实现定义的（通常是将位模式解释为有符号补码）。
示例：
假设 int 和 unsigned int 都是 32 位。
1
int neg_int = -1; // 二进制补码: 全 1 (32个)
2
unsigned int ui = static_cast<unsigned int>(neg_int);
3
// 位模式不变，解释为无符号
4
// 结果 unsigned int: 2^32 - 1
5
std::cout << ui << std::endl; // 输出 4294967295 (假设 32位)
6
7
unsigned int large_uint = 4294967295; // 全 1 (32个)
8
int i = static_cast<int>(large_uint);
9
// 位模式不变，解释为有符号补码
10
// 结果 int: -1 (假设 32位)
11
std::cout << i << std::endl; // 输出 -1
12
13
unsigned int val_uint = 100; // 二进制: ...0000 0110 0100
14
int val_int = static_cast<int>(val_uint);
15
// 100 在 int 范围内，值不变
16
// 结果 int: 100
17
std::cout << val_int << std::endl; // 输出 100
理解截断、符号扩展和零扩展是预测类型转换结果的关键。在使用显式转换时，特别是将大类型转换为小类型或在有符号/无符号之间转换时，需要特别小心这些行为，以避免引入 bug。
总而言之，C++ 的整数类型转换规则既有自动进行的隐式转换（整型提升、算术转换），也有需要程序员明确指定的显式转换（C++ 风格的 static_cast 是首选）。深入理解这些规则，尤其是涉及有符号和无符号类型混合、以及不同位宽类型之间的转换时，是编写安全可靠 C++ 代码的基础。
7. 有符号与无符号整数的交互与陷阱
欢迎来到本书第七章！在前几章中，我们已经详细探讨了 C++ 中有符号整数类型（Signed Integer Types）和无符号整数类型（Unsigned Integer Types）各自的定义、大小、范围、字面量以及基本运算规则。理解这些基础知识是编写正确、健壮 C++ 代码的关键。然而，当有符号整数和无符号整数在表达式中混合使用时，情况可能会变得复杂，并引入一些“陷阱”，导致程序行为与我们的直觉不符。
本章将聚焦于有符号整数和无符号整数之间的交互。我们将深入解析 C++ 标准如何处理这种情况，特别是其中涉及的类型转换规则。通过具体的代码示例，我们将揭示这些交互可能导致的非预期结果和常见的编程错误模式，并提供识别和避免这些陷阱的建议。掌握本章内容，对于编写安全、可靠且可移植的 C++ 代码至关重要。
7.1 有符号与无符号整数的比较
在 C++ 中，当一个有符号整数（Signed Integer）与一个无符号整数（Unsigned Integer）进行比较运算时，C++ 标准规定会将有符号整数隐式地转换（Implicitly Converted）为无符号类型，然后再进行比较。这个规则是 C++ 算术转换（Arithmetic Conversions）的一部分，具体来说，属于常用算术转换（Usual Arithmetic Conversions）。
这个转换规则看似简单，但却可能导致一些违反直觉的结果，尤其当有符号数为负时。因为负数在转换为无符号类型时，其值会发生显著变化。
让我们看一个例子：
1
#include <iostream>
2
3
int main() {
4
int signed_num = -10;
5
unsigned int unsigned_num = 5;
6
7
// 直觉上，-10 < 5 是成立的
8
if (signed_num < unsigned_num) {
9
std::cout << signed_num << " < " << unsigned_num << " (根据直觉)" << std::endl;
10
} else {
11
std::cout << signed_num << " >= " << unsigned_num << " (根据C++规则)" << std::endl;
12
}
13
14
// 发生隐式转换后的比较
15
// signed_num (-10) 被转换为 unsigned int
16
// 在大多数系统使用二进制补码表示下，-10 的 unsigned int 表示是一个非常大的正数
17
unsigned int converted_signed_num = static_cast<unsigned int>(signed_num);
18
std::cout << "将 " << signed_num << " (int) 转换为 unsigned int 得到: " << converted_signed_num << std::endl;
19
20
if (converted_signed_num < unsigned_num) {
21
std::cout << converted_signed_num << " < " << unsigned_num << " (实际比较)" << std::endl;
22
} else {
23
std::cout << converted_signed_num << " >= " << unsigned_num << " (实际比较)" << std::endl;
24
}
25
26
27
return 0;
28
}
在上述代码中，当 signed_num < unsigned_num 进行比较时，-10 会被转换为 unsigned int。一个负的有符号数在转换为同等宽度的无符号类型时，其值会变成原负数加上 \( 2^N \)，其中 \( N \) 是无符号类型的位宽。对于一个 32 位的 unsigned int，-10 会转换为 \( -10 + 2^{32} \)，这是一个非常大的正数（例如，4294967286）。这个非常大的无符号数显然大于 unsigned_num (5)。因此，signed_num < unsigned_num 的结果将是 false，而 signed_num >= unsigned_num 的结果将是 true，这与我们基于数学概念的直觉完全相反。
🔑 核心规则：当有符号数和无符号数进行比较时，有符号数会被提升（Converted）为无符号数。
这个规则的应用场景非常广泛，不仅仅是简单的 < 或 > 比较，包括 ==, !=, <=, >= 等所有比较运算符都会遵循这个规则。
为了避免这种陷阱，通常有以下几种做法：
① 避免混合比较：尽量确保参与比较的两个操作数具有相同的符号性（都是有符号或都是无符号）。
② 强制类型转换：如果必须比较，并且你期望的是基于数学上的大小比较，可以将无符号数显式地转换为有符号数（但要注意无符号数是否超出有符号数的范围，可能导致截断或非预期结果），或者将有符号数转换为更宽的有符号类型再与无符号数比较（这通常更安全，但也需要确保无符号数不超过新有符号类型的最大值）。更常见且推荐的做法是将无符号数转换为有符号数进行比较，前提是确定无符号数的值不会超出有符号数的范围。或者，如果确定有符号数是非负的，可以将其转换为无符号数进行比较。
③ 检查符号：在进行比较前，先检查有符号数是否为负。如果是有符号负数与无符号数比较，有符号数必然小于无符号数（从数学意义上讲）。如果是有符号非负数与无符号数比较，则可以安全地将有符号数转换为无符号数进行比较。
1
#include <iostream>
2
3
int main() {
4
int signed_num = -10;
5
unsigned int unsigned_num = 5;
6
7
// 改进的比较方法
8
if (signed_num < 0) {
9
// 如果有符号数是负数，它在数学上一定小于任何无符号数（因为无符号数总是非负的）
10
std::cout << signed_num << " < " << unsigned_num << " (安全比较)" << std::endl;
11
} else {
12
// 如果有符号数是非负数，可以安全地将其转换为无符号数进行比较
13
if (static_cast<unsigned int>(signed_num) < unsigned_num) {
14
std::cout << signed_num << " < " << unsigned_num << " (安全比较)" << std::endl;
15
} else {
16
std::cout << signed_num << " >= " << unsigned_num << " (安全比较)" << std::endl;
17
}
18
}
19
20
return 0;
21
}
通过这种方式，我们可以避免隐式转换带来的反直觉结果。
7.2 有符号与无符号整数的算术运算
与比较类似，当有符号整数与无符号整数一起参与算术运算（Arithmetic Operations）时，C++ 也会应用隐式类型转换。根据常用算术转换规则，有符号操作数会被转换为与无符号操作数具有相同宽度或更宽的无符号类型。
🔑 核心规则：当有符号数和无符号数进行算术运算时，有符号数会被转换为无符号数。运算结果的类型是转换后的无符号类型。
这意味着，即使运算结果在数学上应该是一个负数，如果参与运算的类型组合触发了无符号转换，最终结果也会是一个无符号数，表示一个大的正数。
考虑以下例子：
1
#include <iostream>
2
3
int main() {
4
int signed_a = -10;
5
unsigned int unsigned_b = 5;
6
7
// 直觉上，-10 + 5 应该等于 -5
8
int result_int = signed_a + unsigned_b; // 实际发生隐式转换
9
10
std::cout << signed_a << " (int) + " << unsigned_b << " (unsigned int)" << std::endl;
11
std::cout << "直接赋给 int 变量的结果: " << result_int << std::endl;
12
13
// 如果将结果直接赋给 unsigned int 变量
14
unsigned int result_unsigned = signed_a + unsigned_b; // 隐式转换发生在加法前，结果是无符号数
15
16
std::cout << "直接赋给 unsigned int 变量的结果: " << result_unsigned << std::endl;
17
18
19
// 进一步分析加法过程
20
// signed_a (-10) 被转换为 unsigned int (假设32位系统，值为 4294967286)
21
// unsigned int result = 4294967286 + 5 = 4294967291
22
// 当这个结果 4294967291 被赋给 int 变量 result_int 时
23
// 发生从 unsigned int 到 int 的转换。如果 4294967291 超出了 int 的最大范围，
24
// 这种转换是有符号溢出，其行为是未定义的（Undefined Behavior）。
25
// 然而，在大多数使用二进制补码的系统上，它会“绕回”到 -5。
26
// 当赋给 unsigned int 变量 result_unsigned 时，就是 4294967291。
27
28
return 0;
29
}
运行这段代码，你可能会看到赋给 int 变量的结果是 -5 (这依赖于未定义行为在你的平台上的表现)，而赋给 unsigned int 变量的结果是一个很大的正数（例如 4294967291）。
💥 潜在问题：这种隐式转换为无符号类型的行为可能导致以下问题：
⚝ 运算结果的符号性与预期不符。
⚝ 运算结果的大小远远超出预期，可能导致后续的逻辑错误、数组越界等。
⚝ 如果将这个大的无符号结果再次转换回有符号类型（例如赋给一个 int 变量），如果值超出目标有符号类型的范围，将触发有符号整数溢出（Signed Integer Overflow），这是 C++ 中的未定义行为（Undefined Behavior），极其危险。
为了避免这些陷阱，同样建议：
① 保持类型一致：在进行算术运算时，尽量确保所有操作数类型一致，或者至少符号性一致。
② 显式转换：如果必须混合使用，应仔细考虑运算的目的，并使用 static_cast 进行显式转换，以控制转换过程。例如，如果你确定有符号数是非负的，并且无符号数的值在有符号数的范围内，可以将无符号数转换为有符号数再运算。反之，如果结果需要是无符号的，或者有符号数可能为负且需要利用无符号数的环绕特性，则可以保持原样（但要清楚行为）。
③ 使用更宽类型：在不确定是否有溢出风险时，可以将一个或两个操作数先转换为一个足够宽的有符号类型（如 long long）再进行运算，这样可以容纳更大的中间结果，减少溢出风险，然后再根据需要将结果转换为目标类型。
例如，为了得到数学上 -5 的结果，可以这样做：
1
#include <iostream>
2
3
int main() {
4
int signed_a = -10;
5
unsigned int unsigned_b = 5;
6
7
// 显式将 unsigned_b 转换为 int，前提是确定 unsigned_b 的值在 int 的范围内
8
int result_safe = signed_a + static_cast<int>(unsigned_b);
9
std::cout << "安全运算结果 (将 unsigned int 转换为 int): " << result_safe << std::endl;
10
11
// 或者转换为更宽的有符号类型
12
long long result_wide = static_cast<long long>(signed_a) + static_cast<long long>(unsigned_b);
13
std::cout << "安全运算结果 (转换为 long long): " << result_wide << std::endl;
14
15
return 0;
16
}
选择哪种显式转换方式取决于具体的场景和需求，但关键在于避免隐式转换带来的不确定性。
7.3 将负数转换为无符号类型
在前两节中，我们多次提到负的有符号数在转换为无符号类型时的特殊行为。本节将更详细地探讨这一转换过程。
当一个有符号整数类型的值被转换为一个无符号整数类型时，如果源值是非负的，转换就非常直接：它的值不变（如果目标类型能够容纳）。然而，如果源值是负的，转换规则如下：
🔑 负有符号数转换为无符号数规则：将源有符号值加上或减去目标无符号类型能够表示的最大值加一，直到值落在目标无符号类型的范围内。
数学上等价于：如果源值为 \( S \)，目标无符号类型的位宽为 \( N \)，则转换后的无符号值为 \( S \pmod{2^N} \)（这里的模运算定义为结果与被除数同号，但对于 C++ 无符号类型转换，更精确的描述是 \( S + k \times 2^N \)，其中 \( k \) 是使得结果落在无符号类型 \([0, 2^N - 1]\) 范围内的最小整数）。
由于大多数现代系统使用二进制补码表示有符号整数，这种转换的结果通常可以直观地理解为保持底层的位模式不变，只是改变了解释方式。例如，一个 32 位系统上，有符号整数 -1 的二进制表示是全为 1（0xFFFFFFFF）。将其解释为无符号整数，其值就是 \( 2^{32} - 1 \)，即 unsigned int 的最大值。有符号整数 -10 的二进制表示（假设是 0xFFFFFFF6），转换为无符号数时，就对应于该位模式表示的无符号值 \( 2^{32} - 10 \)。
让我们通过代码验证一下：
1
#include <iostream>
2
#include <limits>
3
4
int main() {
5
int neg_signed = -10;
6
unsigned int converted_unsigned = static_cast<unsigned int>(neg_signed);
7
8
std::cout << "有符号负数: " << neg_signed << std::endl;
9
std::cout << "转换为无符号数: " << converted_unsigned << std::endl;
10
11
// 验证转换结果是否等于 原值 + 2^N
12
unsigned int max_unsigned_plus_one = std::numeric_limits<unsigned int>::max() + 1; // 2^N
13
std::cout << "unsigned int 的最大值 + 1 (2^N): " << max_unsigned_plus_one << std::endl;
14
15
// 注意：直接计算 neg_signed + max_unsigned_plus_one 仍然涉及混合类型运算，
16
// 可能会再次触发隐式转换。更安全的方式是直接检查转换后的值是否符合预期。
17
// 在二进制补码系统上，converted_unsigned 应该等于 原负数 + 2^N
18
// (这里的加法是在数学意义上的，不是C++语言中的)
19
// 我们可以通过位模式来理解。
20
21
// 另一种理解方式：无符号数的环绕特性
22
// 无符号数运算是模运算 (Modulo Arithmetic)
23
// 理论上，负数 S 转换为无符号数，相当于计算 S % 2^N，结果落在 [0, 2^N-1]
24
// 对于负数， S % 2^N = S + k * 2^N，取 k 使得结果非负且最小。
25
// 例如，-10 转换为 unsigned int (N=32), 结果是 -10 + 1 * 2^32 = -10 + 4294967296 = 4294967286
26
27
return 0;
28
}
输出结果会显示 -10 转换为 unsigned int 后变成一个非常大的正数。
🔑 应用场景与风险：
⚝ 应用场景：有时这种转换特性被用于实现模运算或位操作，因为无符号数的操作天然具有模运算的性质。
⚝ 风险：在不理解这个规则的情况下，将一个负数赋给无符号变量，或者在涉及负有符号数的表达式中触发无符号转换，很容易产生非预期的巨大正数结果，从而导致程序逻辑错误。
例如，一个常见的错误是使用无符号类型表示容器的大小或循环计数，然后与可能为负的索引或差值进行比较或运算。
1
#include <vector>
2
#include <iostream>
3
4
int main() {
5
std::vector<int> vec = {1, 2, 3, 4, 5};
6
int index = -1; // 一个无效的索引
7
8
// 尝试使用负索引访问（这是未定义行为，这里仅作示例）
9
// vec[index] 会导致问题
10
11
// 另一个问题：循环条件
12
for (unsigned int i = vec.size() - 1; i >= 0; --i) { // 注意这里的 i >= 0
13
std::cout << "Trying to access element at index: " << i << std::endl;
14
// std::cout << vec[i] << std::endl; // 当 i 最终为 0 时，--i 发生无符号下溢
15
// 0 的 unsigned int 减 1 会变成 unsigned int 的最大值
16
}
17
18
return 0;
19
}
在上面的 for 循环中，i 是一个 unsigned int。当 i 减到 0 时，循环条件 i >= 0 对于无符号数 i 总是为真，因为无符号数永远非负。更危险的是，--i 当 i 为 0 时会发生无符号下溢（Underflow），结果变成 unsigned int 的最大值，导致循环无法终止，或者尝试访问一个巨大的无效索引，引发严重错误。
正确的对一个无符号变量进行递减循环直到 0 的方法是检查 i > 0 或者使用特殊的循环结构，或者使用有符号类型作为循环计数器（如果范围允许且更符合逻辑）。
1
#include <vector>
2
#include <iostream>
3
4
int main() {
5
std::vector<int> vec = {1, 2, 3, 4, 5};
6
7
// 正确的递减循环 (C++11 onwards, range-based for loop is often better)
8
for (int i = static_cast<int>(vec.size()) - 1; i >= 0; --i) {
9
std::cout << "Accessing element at index: " << i << std::endl;
10
std::cout << vec[static_cast<size_t>(i)] << std::endl; // 访问时转换为 size_t 是安全的
11
}
12
// 或者对于无符号类型本身的递减循环
13
unsigned int count = 5;
14
while (count > 0) {
15
--count;
16
std::cout << "Count is: " << count << std::endl;
17
}
18
// 或者使用 do-while 循环如果需要执行至少一次
19
unsigned int another_count = 5;
20
if (another_count > 0) {
21
do {
22
--another_count;
23
std::cout << "Another count is: " << another_count << std::endl;
24
} while (another_count > 0);
25
}
26
27
return 0;
28
}
可见，理解无符号类型的环绕行为以及与有符号类型混合时的转换规则，对于避免此类错误至关重要。
7.4 常见的有符号/无符号错误模式
基于前几节的讨论，我们可以总结出一些常见的有符号与无符号整数混合使用导致的错误模式。识别这些模式是提高代码健壮性的重要一步。
7.4.1 循环和索引计算中的陷阱
这是一个非常普遍的陷阱，尤其是在处理容器（Containers）或数组时。C++ 标准库容器（如 std::vector, std::string 等）的大小通常由 size_t 类型表示，这是一个无符号类型。当使用有符号整数作为索引或在涉及容器大小的循环中使用有符号整数时，很容易触发隐式转换。
例如：
1
#include <vector>
2
#include <iostream>
3
4
int main() {
5
std::vector<int> data = {10, 20, 30};
6
int negative_index = -1;
7
8
// 危险的比较：有符号负数 vs 无符号容器大小
9
if (negative_index < data.size()) { // data.size() 返回 size_t (无符号)
10
// 这里的比较 -1 < 3U 会将 -1 转换为一个非常大的无符号数
11
// 这个非常大的无符号数 > 3U，所以条件为假
12
// 这导致了一个逻辑错误：我们期望 -1 小于任何有效索引，但条件判断错误。
13
std::cout << "错误判断: -1 < data.size() 结果为真？ 不会！" << std::endl;
14
} else {
15
std::cout << "正确判断 (基于C++规则): -1 < data.size() 结果为假" << std::endl;
16
}
17
18
// 循环示例：试图从后往前遍历
19
// 如果 data.size() 为 0， data.size() - 1 会发生无符号下溢，结果是 size_t 最大值
20
for (size_t i = data.size() - 1; i >= 0; --i) { // 条件 i >= 0
21
std::cout << "遍历索引: " << i << std::endl; // 当 i 为 0 时，i >= 0 仍然为真
22
// --i 发生无符号下溢，变成 size_t 的最大值，循环继续
23
if (i == 0) {
24
std::cout << "索引 i 达到 0, 下一次循环 i 将下溢!" << std::endl;
25
// break; // 需要手动中断以避免无限循环和潜在的越界访问
26
}
27
}
28
29
// 正确的循环示例 (使用有符号索引)
30
for (int i = static_cast<int>(data.size()) - 1; i >= 0; --i) {
31
std::cout << "安全遍历索引: " << i << std::endl;
32
}
33
34
return 0;
35
}
🔑 避免策略：
① 当与无符号类型（如 size_t）进行比较或运算时，确保另一个操作数也是无符号类型，或者小心地将有符号数转换为无符号数（前提是确定它非负）。
② 更好的做法是，如果可能出现负值（如索引差、计数差），使用有符号类型，并确保其范围足够大。在与无符号类型交互时，进行显式类型转换，并考虑值是否超出目标类型范围。例如，将有符号索引 i 用于访问容器时，可以写 container[static_cast<size_t>(i)]，但这需要你保证 i 是一个有效的非负索引。
③ 对于从大到小的循环，如果必须使用无符号类型，应将循环条件写成 i > 0，并在循环体内部处理索引 0 的情况，或者使用 while (i-- > 0) 这样的结构（但要注意 i 的初始值）。如前所示，使用有符号类型通常更安全。
7.4.2 缓冲区大小检查
在涉及缓冲区（Buffer）操作，如复制、读取、写入时，经常需要检查长度或偏移量，这些通常用无符号类型表示。如果用有符号整数来表示长度或偏移量，或者用有符号整数与无符号长度进行比较，就容易出错。
1
#include <iostream>
2
#include <vector>
3
4
void process_buffer(const std::vector<char>& buffer, int offset, int count) {
5
// buffer.size() 是无符号类型 (size_t)
6
// offset 和 count 是有符号类型
7
8
// 危险的检查：offset + count 是否超出 buffer 大小？
9
// 这里的加法 offset + count 涉及有符号和无符号运算 (如果 offset 是负数，且 count 是 unsigned)
10
// 更常见的是 offset 和 count 都是 int
11
// 然后与 buffer.size() (size_t) 比较
12
if (offset + count > buffer.size()) { // 潜在陷阱!
13
// 假设 offset = 10, count = 20, buffer.size() = 25
14
// 10 + 20 = 30
15
// 30 (int) > 25 (size_t) ?
16
// 30 被转换为 size_t (还是 30), 30 > 25, 条件为真，检查正确。
17
18
// 假设 offset = -10, count = 20, buffer.size() = 25
19
// -10 + 20 = 10
20
// 10 (int) > 25 (size_t) ?
21
// 10 被转换为 size_t (还是 10), 10 > 25, 条件为假。
22
// 错误! 负数 offset + count 即使结果为正，与无符号数比较时，整个表达式可能被提升为无符号，
23
// 导致非预期结果，或者当 offset 或 count 为负时，表达式 offset + count 本身就可能因为隐式转换而是一个巨大的无符号数。
24
// 更直接的风险是，如果 offset 是负数，尽管 count 很大， offset+count 结果可能看起来有效，
25
// 但 offset 本身就是无效的起始位置。
26
27
std::cerr << "错误：访问超出缓冲区范围！" << std::endl;
28
return;
29
}
30
31
// 正确的检查方法之一：
32
// 1. 检查 offset 是否为负或超出范围
33
if (offset < 0 || static_cast<size_t>(offset) > buffer.size()) {
34
std::cerr << "错误：无效的偏移量！" << std::endl;
35
return;
36
}
37
// 2. 检查 offset + count 是否超出范围，确保加法在有符号类型中进行，或者转换为足够宽的类型
38
// 并且 count 也必须是非负的
39
if (count < 0 || static_cast<size_t>(offset) + static_cast<size_t>(count) > buffer.size()) {
40
std::cerr << "错误：访问超出缓冲区范围！" << std::endl;
41
return;
42
}
43
// 或者更简洁，但需要仔细理解类型转换
44
if (static_cast<size_t>(offset) + static_cast<size_t>(count) > buffer.size()) { // 前提是 offset 和 count 都确保了非负
45
std::cerr << "错误：访问超出缓冲区范围！" << std::endl;
46
return;
47
}
48
// 如果 offset 和 count 都是 int，且可能为负
49
if (offset < 0 || count < 0) {
50
std::cerr << "错误：偏移量或计数不能为负！" << std::endl;
51
return;
52
}
53
if (static_cast<size_t>(offset) + static_cast<size_t>(count) > buffer.size()) {
54
std::cerr << "错误：访问超出缓冲区范围！" << std::endl;
55
return;
56
}
57
58
59
std::cout << "缓冲区访问有效。" << std::endl;
60
// ... 进行缓冲区操作 ...
61
}
62
63
int main() {
64
std::vector<char> data(30);
65
process_buffer(data, 10, 20); // 有效访问
66
process_buffer(data, 10, 21); // 无效访问
67
process_buffer(data, -5, 10); // 危险的 offset
68
process_buffer(data, 20, -5); // 危险的 count
69
process_buffer(data, 35, 10); // 无效的 offset
70
return 0;
71
}
🔑 避免策略：
① 表示大小、容量、索引等永不为负的值时，优先考虑使用无符号类型，特别是 size_t。
② 在进行涉及大小、索引的计算和比较时，确保所有相关变量类型一致。如果必须混合使用，进行显式类型转换，并且务必在转换前或转换后检查数值是否落在预期范围内，特别是将有符号数转换为无符号数，或将无符号数转换为有符号数时。
③ 对于需要处理可能为负的相对偏移或差值，使用有符号类型，但在与无符号大小或索引交互前进行适当的检查和转换。
7.4.3 最小/最大值比较
当比较变量与整数类型的最小或最大可能值时，混合使用有符号和无符号类型也可能导致问题。numeric_limits 提供的 min(), max(), lowest() 等函数对于各种类型都可用。
1
#include <iostream>
2
#include <limits>
3
4
int main() {
5
int value = -1;
6
unsigned int max_unsigned = std::numeric_limits<unsigned int>::max();
7
8
// 危险的比较：有符号数 value 与无符号最大值 max_unsigned
9
if (value < max_unsigned) { // -1 < MAX_UINT
10
// -1 被转换为无符号类型的 MAX_UINT
11
// MAX_UINT < MAX_UINT 是假
12
std::cout << "错误判断: value < max_unsigned 结果为真？ 不会！" << std::endl;
13
} else {
14
std::cout << "正确判断 (基于C++规则): value < max_unsigned 结果为假" << std::endl;
15
}
16
17
// 正确的比较：将 value 转换为无符号类型（如果确定非负）
18
// if (static_cast<unsigned int>(value) < max_unsigned) { ... } // 对于负数不适用
19
20
// 正确的比较：将 max_unsigned 转换为有符号类型（如果 max_unsigned 不超过有符号类型的最大值）
21
// 或者转换为更宽的有符号类型
22
if (value < static_cast<long long>(max_unsigned)) {
23
std::cout << "安全判断: value < max_unsigned 结果为真" << std::endl;
24
}
25
26
27
return 0;
28
}
🔑 避免策略：
① 在比较变量与类型的极值时，确保变量类型与极值类型匹配，或者在比较前进行适当的类型转换。
② 当将变量与无符号类型的最大值比较时，如果变量可能为负，直接比较会因为隐式转换而失败。可以将变量转换为一个足够宽的有符号类型，再与无符号类型的最大值（转换为同等宽度的有符号类型）进行比较。
7.4.4 使用字面量时的陷阱
整数字面量（Integer Literals）本身也有类型。它们的类型推断规则（如 4.3 节所述）可能导致它们是有符号或无符号的。当字面量与变量混合使用时，也可能触发隐式转换。
例如，在一个 32 位系统上，字面量 4000000000 会被推断为 unsigned int，因为它超出了 32 位 int 的最大值（约 20 亿）。
1
#include <iostream>
2
3
int main() {
4
int negative_val = -1;
5
// 危险的比较：有符号变量 vs 大的无符号字面量
6
if (negative_val < 4000000000) { // -1 < 4000000000U
7
// -1 被转换为 unsigned int (4294967295)
8
// 4294967295U < 4000000000U 结果为假
9
std::cout << "错误判断: -1 < 4000000000 结果为真？ 不会！" << std::endl;
10
} else {
11
std::cout << "正确判断 (基于C++规则): -1 < 4000000000 结果为假" << std::endl;
12
}
13
14
// 如果字面量在一个有符号类型范围内
15
if (negative_val < 100U) { // -1 < 100U
16
// -1 被转换为 unsigned int (4294967295)
17
// 4294967295U < 100U 结果为假
18
std::cout << "错误判断: -1 < 100U 结果为真？ 不会！" << std::endl;
19
} else {
20
std::cout << "正确判断 (基于C++规则): -1 < 100U 结果为假" << std::endl;
21
}
22
23
if (negative_val < 100) { // -1 < 100
24
// 两边都是 int，直接比较 -1 < 100，结果为真
25
std::cout << "安全判断: -1 < 100 结果为真" << std::endl;
26
}
27
28
return 0;
29
}
🔑 避免策略：
① 当使用较大的整数字面量时，要清楚其类型推断规则，必要时使用类型后缀（Suffixes）显式指定类型（如 4000000000ULL 表示 unsigned long long）。
② 在比较或运算中混合使用字面量和变量时，考虑可能发生的隐式转换，并根据需要进行显式转换。
7.4.5 位移操作中的陷阱
位移操作符 << 和 >> 在处理有符号和无符号数时行为是不同的，特别是在右移（>>）时。
⚝ 有符号右移：算术右移（Arithmetic Right Shift）。移位后，最高位（符号位）通常会复制原始符号位的值（保持符号不变）。但是，对负数进行右移操作，其行为是实现定义的（Implementation-Defined），这意味着不同的编译器可能会有不同的行为。
⚝ 无符号右移：逻辑右移（Logical Right Shift）。移位后，最高位总是填充 0。
1
#include <iostream>
2
#include <bitset> // 用于显示二进制表示
3
4
int main() {
5
int signed_val = -10; // 假设 32 位 int, 二进制补码表示
6
// 可能是 1111...1110110
7
8
unsigned int unsigned_val = 4294997286U; // 对应 -10 的无符号表示，二进制同上
9
10
std::cout << "有符号数 -10 的二进制 (假设32位): " << std::bitset<32>(signed_val) << std::endl;
11
std::cout << "无符号数 4294967286 的二进制 (假设32位): " << std::bitset<32>(unsigned_val) << std::endl;
12
13
14
// 有符号右移 (行为实现定义)
15
int signed_shifted_right = signed_val >> 2;
16
std::cout << "有符号数 -10 右移 2 位 (结果依赖实现): " << signed_shifted_right << std::endl;
17
// 在大多数实现中，会执行算术右移，结果仍为负，例如 -3 或 -2
18
19
// 无符号右移
20
unsigned int unsigned_shifted_right = unsigned_val >> 2;
21
std::cout << "无符号数 4294967286 右移 2 位: " << unsigned_shifted_right << std::endl;
22
// 会执行逻辑右移，高位填充 0，结果是一个正数
23
24
// 危险：对负数进行左移操作
25
// int signed_shifted_left = signed_val << 2; // 如果 signed_val * 2^2 发生有符号溢出，这是未定义行为！
26
// std::cout << "有符号数 -10 左移 2 位 (如果溢出是未定义行为): " << signed_shifted_left << std::endl;
27
28
// 危险：移位位数 >= 操作数的位宽，或为负数
29
// int invalid_shift = signed_val >> 32; // 假设 32 位 int, 移位位数 >= 32，未定义行为
30
// int invalid_shift_neg = signed_val >> -2; // 移位位数为负数，未定义行为
31
32
33
return 0;
34
}
🔑 避免策略：
① 明确位移操作的对象：如果需要进行位操作，特别是右移，且不希望符号位扩展，或者需要对表示位模式的数值进行操作，优先使用无符号类型。
② 避免对负的有符号数进行右移，因为其行为是实现定义的。
③ 避免左移操作导致有符号数溢出，这是未定义行为。
④ 绝对避免移位位数为负数或大于等于操作数的位宽，这都是未定义行为。移位位数通常应使用无符号类型（例如 size_t 或更窄的无符号类型），并且必须小于操作数的位宽。
本章详细探讨了有符号与无符号整数类型混合使用时可能遇到的问题。理解这些规则和潜在陷阱，并通过显式类型转换、选择合适的类型以及仔细检查边界条件来避免它们，是编写可靠 C++ 代码的关键。在下一章中，我们将总结使用整数类型的最佳实践，并进一步探讨如何利用编译器警告等工具来帮助我们写出更好的代码。
好的，作为一名资深的讲师，我将为您深度解析 C++ 整数类型使用中的最佳实践与常见问题。我们将严格按照您提供的章节大纲和输出格式进行。
8. 整数类型的使用最佳实践与常见问题
本章旨在总结 C++ 中使用整数类型的经验和建议，帮助读者避免常见的编程错误，提升代码的健壮性和可读性。理解并遵循这些最佳实践对于编写高质量的 C++ 代码至关重要。
8.1 选择合适的整数类型
在 C++ 编程中，选择合适的整数类型是构建高效、安全且易于维护代码的第一步。不同的整数类型提供了不同的大小（size）和数值范围（value range），合理的选择应权衡程序的需求、性能考量以及内存限制。
① int：通用选择
▮▮▮▮通常情况下，int 是你的首选。它被设计成与执行环境的自然字长（word size）相匹配，这意味着对 int 类型的操作通常是效率最高的。
▮▮▮▮在大多数现代系统上，int 是 32 位宽，可以表示大约 \(\pm 2 \times 10^9\) 范围内的数值。
▮▮▮▮使用 int 适用于大多数计数器、索引、循环变量以及不涉及极端数值计算的场景。
▮▮▮▮除非有明确的理由（如需要更大的范围、确切的宽度或内存限制），否则优先使用 int 可以提高代码的可移植性和执行效率。
② short：内存受限场景
▮▮▮▮short int（通常简写为 short）至少保证 16 位宽度。
▮▮▮▮如果内存资源极其有限（例如在嵌入式系统编程中），并且确定所需的数值范围不超过 short 所能表示的范围，那么使用 short 可以节省内存。
▮▮▮▮然而，在现代桌面或服务器应用中，由于内存不再是主要瓶颈，而对小于机器字长的类型进行操作有时需要额外的指令，short 的使用并不如 int 常见，并且可能不会带来性能优势，有时甚至会稍慢。
③ long 和 long long：更大的范围
▮▮▮▮long int（通常简写为 long）至少保证 32 位宽度。在某些系统（如 64 位 Linux）上，long 是 64 位宽。
▮▮▮▮long long int（通常简写为 long long）是 C++11 引入的标准类型，至少保证 64 位宽度。这是 C++ 标准基本整数类型中能保证的最大范围的类型。
▮▮▮▮当你的程序需要处理可能超过 int 最大值（例如，人口计数、文件大小、时间戳、金融计算等）的数值时，应该使用 long 或 long long。
▮▮▮▮选择 long 还是 long long 取决于所需的确切范围以及目标平台的 long 的实际大小。为了最大的可移植性来处理大数值，long long 通常是更保险的选择。
④ char：字符或小范围字节值
▮▮▮▮char 是最小的整数类型，用于存储字符或字节值。它至少保证 8 位。
▮▮▮▮signed char 明确表示有符号的 8 位整数。
▮▮▮▮unsigned char 明确表示无符号的 8 位整数，常用于处理原始字节数据（如图片、文件流）。
▮▮▮▮char 本身是否为有符号或无符号是实现定义（implementation-defined）的，这导致它不适合直接用于数值计算，除非你确定或指定了 signed char 或 unsigned char。
⑤ 无符号类型（Unsigned Types）：非负值和位操作
▮▮▮▮unsigned int, unsigned long, unsigned long long 等类型用于表示非负的数值。
▮▮▮▮它们的优势在于，对于相同的位宽，它们可以表示的正数值范围比有符号类型大一倍（从 0 到 \(2^N-1\)，其中 N 是位宽）。
▮▮▮▮无符号类型特别适用于表示数量（如集合大小、数组索引）、位标志（bit flags）以及需要环绕行为（wrap-around behavior）的场景（尽管通常应避免依赖环绕行为）。
▮▮▮▮处理原始内存或进行位操作（bitwise operations）时，unsigned char 或其他无符号类型是标准做法，因为它们不会引入有符号数相关的复杂性（如符号位、二进制补码表示的负数等）。
⑥ 固定宽度整数类型（Fixed-width Integer Types）：精确控制
▮▮▮▮对于需要精确控制整数位宽的场景（例如，与硬件寄存器交互、网络协议、跨平台序列化），应使用 <cstdint> 头文件中定义的固定宽度整数类型，如 int32_t, uint64_t 等。
▮▮▮▮这些类型在 Chapter 9 中会更详细地介绍。它们的优点是提供了更好的可移植性和明确性，消除了不同平台上基本整数类型大小不确定的问题。缺点是它们不一定存在于所有平台上，或者不一定是最高效的类型。
⑦ 总结选择建议
⚝ 对于一般的数值或计数，优先使用 int。
⚝ 当需要确定的非负范围或进行位操作时，使用对应的 unsigned 类型。
⚝ 当需要处理可能超出 int 范围的大数值时，使用 long long。
⚝ 在对位宽有精确要求或需要最大可移植性时，使用 <cstdint> 中的固定宽度类型。
⚝ 仅在严格的内存限制下，且确定范围足够小，或者处理原始字节时，考虑 short 或 char 系列类型。
示例：
1
#include <iostream>
2
#include <cstdint> // for fixed-width types
3
#include <vector> // for size_t
4
5
int main() {
6
int counter = 0; // 通用计数器，通常足够
7
8
unsigned int flags = 0x0F; // 位标志，使用无符号类型
9
10
long long big_number = 123456789012345LL; // 需要处理大数
11
12
std::vector<int> data = {1, 2, 3, 4, 5};
13
size_t size = data.size(); // 容器大小，使用 size_t (通常是 unsigned)
14
15
int16_t sensor_reading = -100; // 需要确切的 16 位有符号值
16
17
unsigned char byte_value = 255; // 处理原始字节
18
19
std::cout << "int size: " << sizeof(int) << " bytes" << std::endl;
20
std::cout << "long long size: " << sizeof(long long) << " bytes" << std::endl;
21
std::cout << "size_t size: " << sizeof(size_t) << " bytes" << std::endl;
22
std::cout << "int16_t size: " << sizeof(int16_t) << " bytes" << std::endl;
23
std::cout << "unsigned char size: " << sizeof(unsigned char) << " bytes" << std::endl;
24
25
return 0;
26
}
8.2 警惕整数溢出
整数溢出（Integer Overflow）是 C++ 中一个常见的、潜在的严重问题。当一个算术运算的结果超出该类型所能表示的最大或最小值时，就会发生溢出。有符号整数溢出和无符号整数溢出的行为是不同的，其中有符号整数溢出导致未定义行为（Undefined Behavior），这是极其危险的。
① 有符号整数溢出（Signed Integer Overflow）
▮▮▮▮当有符号整数运算产生的结果超出了该类型能表示的范围时，其行为是未定义（Undefined Behavior）的。
▮▮▮▮这意味着编译器可以自由地执行任何操作：程序可能会崩溃、产生错误的结果、或者似乎正常运行但带有隐藏的错误。你不能依赖任何特定的溢出行为。
▮▮▮▮未定义行为是 C++ 中最难调试的 bug 之一，因为它可能在不同的编译器、不同的优化级别、不同的运行时环境下表现出不同的症状，甚至在某些情况下根本不表现出来。
示例：
1
#include <iostream>
2
#include <limits> // For std::numeric_limits
3
4
int main() {
5
int max_int = std::numeric_limits<int>::max();
6
int large_number = 100;
7
8
// 潜在的有符号整数溢出：max_int + large_number > max_int
9
int result = max_int + large_number; // Undefined Behavior!
10
11
std::cout << "Max int: " << max_int << std::endl;
12
// 输出的结果是不可预测的，可能是一个负数，或者其他意想不到的值
13
std::cout << "max_int + 100 = " << result << std::endl;
14
15
return 0;
16
}
▮▮▮▮在上述示例中，max_int + large_number 的结果超出了 int 的范围，这是有符号整数溢出，触发了未定义行为。
② 无符号整数溢出（Unsigned Integer Overflow）
▮▮▮▮与有符号整数不同，无符号整数的溢出行为是良好定义（well-defined）的。
▮▮▮▮当无符号整数运算结果超出其范围时，结果会环绕（wrap around）。这意味着结果是模 \(2^N\) 的值，其中 N 是该无符号类型的位宽。
▮▮▮▮例如，一个 8 位的无符号整数（范围 0-255），如果计算结果是 256，实际存储的值是 \(256 \pmod{256} = 0\)；如果结果是 257，实际存储的值是 \(257 \pmod{256} = 1\)。
示例：
1
#include <iostream>
2
#include <limits> // For std::numeric_limits
3
4
int main() {
5
unsigned int max_uint = std::numeric_limits<unsigned int>::max();
6
unsigned int large_number = 100;
7
8
// 无符号整数溢出：行为良好定义，结果会环绕
9
unsigned int result = max_uint + large_number; // Well-defined wrap-around
10
11
std::cout << "Max unsigned int: " << max_uint << std::endl;
12
// 结果是 (max_uint + 100) % (max_uint + 1)
13
std::cout << "max_uint + 100 = " << result << std::endl;
14
15
return 0;
16
}
③ 避免和检测整数溢出的策略
▮▮▮▮尽管无符号整数溢出是良好定义的，但它通常也不是你想要的结果。因此，避免所有类型的整数溢出是良好的编程实践。
策略包括：
⚝ 使用足够大的类型： 如果你知道数值可能很大，使用 long long 或 <cstdint> 中保证更大范围的类型（如 int64_t 或 uint64_t）。
⚝ 操作前进行范围检查： 在执行可能导致溢出的操作（如加法、减法、乘法）之前，检查操作数是否在不会导致溢出的范围内。
▮▮▮▮例如，对于有符号加法 a + b，如果 a > 0 且 b > 0，检查是否 a > INT_MAX - b。如果 a < 0 且 b < 0，检查是否 a < INT_MIN - b。
▮▮▮▮对于乘法 a * b，检查是否 a > INT_MAX / b (assuming b > 0) 等等。这些检查需要根据具体操作符和操作数的符号进行。
⚝ 使用编译器警告和静态分析工具： 现代编译器和静态分析工具可以检测出一些明显的溢出风险。开启相关的警告（如 -Woverflow）。
⚝ 使用检查溢出的库或函数： 一些库（如 Boost.SafeNumerics）提供了“安全”的数值类型，会在运行时检查溢出并抛出异常。或者自己实现或使用检查溢出的辅助函数。
⚝ 注意循环和迭代： 使用整数类型作为循环计数器或数组索引时，要特别小心边界条件，确保计数器不会溢出或与无符号索引混合导致问题（详见 Chapter 7）。## 8. 整数类型的使用最佳实践与常见问题
本章旨在总结 C++ 中使用整数类型的经验和建议，帮助读者避免常见的编程错误，提升代码的健壮性和可读性。理解并遵循这些最佳实践对于编写高质量的 C++ 代码至关重要。作为一名负责任的讲师，我将通过详细的解释和示例，引导大家掌握这些要点。🎯
8.1 选择合适的整数类型
在 C++ 编程中，选择合适的整数类型是构建高效、安全且易于维护代码的第一步。不同的整数类型提供了不同的大小（size）和数值范围（value range），合理的选择应权衡程序的需求、性能考量以及内存限制。
① int：通用选择
▮▮▮▮通常情况下，int 是你的首选。它被设计成与执行环境的自然字长（word size）相匹配，这意味着对 int 类型的操作通常是效率最高的。
▮▮▮▮在大多数现代系统上，int 是 32 位宽，可以表示大约 \(\pm 2 \times 10^9\) 范围内的数值。在少数老旧或嵌入式系统上，它可能是 16 位。
▮▮▮▮使用 int 适用于大多数计数器、索引、循环变量以及不涉及极端数值计算的场景。
▮▮▮▮除非有明确的理由（如需要更大的范围、确切的宽度或内存限制），否则优先使用 int 可以提高代码的可移植性和执行效率。这也是 C++ Standard Library（标准库）中许多函数默认使用 int 的原因。
② short：内存受限场景
▮▮▮▮short int（通常简写为 short）至少保证 16 位宽度。
▮▮▮▮如果内存资源极其有限（例如在嵌入式系统编程中），并且确定所需的数值范围不超过 short 所能表示的范围，那么使用 short 可以节省内存。
▮▮▮▮然而，在现代桌面或服务器应用中，由于内存不再是主要瓶颈，而对小于机器字长的类型进行操作有时需要额外的指令（例如，加载、符号扩展或零扩展到寄存器大小），short 的使用并不如 int 常见，并且可能不会带来性能优势，有时甚至会稍慢。
③ long 和 long long：更大的范围
▮▮▮▮long int（通常简写为 long）至少保证 32 位宽度。在某些系统（如 64 位 Linux）上，long 是 64 位宽。Windows 64 位系统上的 long 仍然是 32 位。这种平台差异性是需要警惕的。
▮▮▮▮long long int（通常简写为 long long）是 C++11 引入的标准类型，至少保证 64 位宽度。这是 C++ 标准基本整数类型中能保证的最大范围的类型。
▮▮▮▮当你的程序需要处理可能超过 int 最大值（例如，人口计数、文件大小、时间戳、金融计算等）的数值时，应该使用 long 或 long long。
▮▮▮▮选择 long 还是 long long 取决于所需的确切范围以及目标平台的 long 的实际大小。为了最大的可移植性来处理大数值，long long 通常是更保险的选择。
④ char：字符或小范围字节值
▮▮▮▮char 是最小的整数类型，用于存储字符或字节值。它至少保证 8 位。
▮▮▮▮signed char 明确表示有符号的 8 位整数，范围通常是 -128 到 127。
▮▮▮▮unsigned char 明确表示无符号的 8 位整数，范围通常是 0 到 255。常用于处理原始字节数据（如图片、文件流、网络数据）。
▮▮▮▮char 本身是否为有符号或无符号是实现定义（implementation-defined）的，这导致它不适合直接用于数值计算，除非你确定或指定了 signed char 或 unsigned char。在处理文本字符时，char 的有无符号通常不重要，但在将 char 转换为更大的整数类型时，有无符号的差异就会体现出来（涉及符号扩展 vs 零扩展）。
⑤ 无符号类型（Unsigned Types）：非负值和位操作
▮▮▮▮unsigned int, unsigned long, unsigned long long 等类型用于表示非负的数值。
▮▮▮▮它们的优势在于，对于相同的位宽，它们可以表示的正数值范围比有符号类型大一倍（从 0 到 \(2^N-1\)，其中 N 是位宽）。
▮▮▮▮无符号类型特别适用于表示数量（如集合大小、数组索引）、位标志（bit flags）以及需要环绕行为（wrap-around behavior）的场景（尽管通常应避免依赖环绕行为进行数值计算）。
▮▮▮▮处理原始内存或进行位操作（bitwise operations）时，unsigned char 或其他无符号类型是标准做法，因为它们不会引入有符号数相关的复杂性（如符号位、二进制补码表示的负数等）。
⑥ 固定宽度整数类型（Fixed-width Integer Types）：精确控制
▮▮▮▮对于需要精确控制整数位宽的场景（例如，与硬件寄存器交互、网络协议、跨平台序列化、精确控制数值范围以避免溢出），应使用 <cstdint> 头文件中定义的固定宽度整数类型，如 int32_t, uint64_t 等。
▮▮▮▮这些类型在 Chapter 9 中会更详细地介绍。它们的优点是提供了更好的可移植性和明确性，消除了不同平台上基本整数类型大小不确定的问题。缺点是它们是可选的类型（不是所有平台都必须提供所有宽度），或者在某些平台/编译器上，使用它们可能不会像使用基本类型那样高效。
⑦ 总结选择建议
⚝ 默认： 对于一般的数值或计数，优先使用 int。它通常能满足需求且效率最高。
⚝ 非负计数或位操作： 当需要确定的非负范围或进行位操作时，使用对应的 unsigned 类型（如 unsigned int, size_t）。
⚝ 大数值： 当需要处理可能超出 int 范围的大数值时，使用 long long。
⚝ 精确位宽/跨平台： 在对位宽有精确要求或需要最大跨平台可移植性时，使用 <cstdint> 中的固定宽度类型（如 int32_t, uint64_t）。
⚝ 字节数据： 处理原始字节数据时，使用 unsigned char。
⚝ 内存限制： 仅在严格的内存限制下，且确定范围足够小，才考虑 short。
示例：
1
#include <iostream>
2
#include <cstdint> // for fixed-width types like int32_t, uint64_t
3
#include <vector> // for size_t
4
#include <limits> // for numeric_limits
5
6
int main() {
7
int counter = 0; // 通用计数器，通常足够，效率高
8
9
unsigned int flags = 0; // 位标志，使用无符号类型更自然
10
flags |= (1u << 3); // 设置第4个位
11
12
long long population = 8000000000LL; // 全球人口，超出 int 范围，需要 long long
13
14
std::vector<int> data = {10, 20, 30, 40, 50};
15
size_t size = data.size(); // 容器大小，标准推荐使用 size_t (无符号类型)
16
17
int32_t network_packet_length = 1400; // 需要确切的 32 位有符号值，用于网络协议
18
19
unsigned char byte_buffer[16]; // 存储原始字节数据，使用 unsigned char
20
21
std::cout << "sizeof(int): " << sizeof(int) << std::endl;
22
std::cout << "sizeof(long long): " << sizeof(long long) << std::endl;
23
std::cout << "sizeof(size_t): " << sizeof(size_t) << std::endl;
24
std::cout << "sizeof(int32_t): " << sizeof(int32_t) << std::endl;
25
std::cout << "sizeof(unsigned char): " << sizeof(unsigned char) << std::endl;
26
27
std::cout << "int max: " << std::numeric_limits<int>::max() << std::endl;
28
std::cout << "long long max: " << std::numeric_limits<long long>::max() << std::endl;
29
30
return 0;
31
}
在这个例子中，我们根据不同的用途选择了不同的整数类型，体现了“选择合适的整数类型”的原则。
8.2 警惕整数溢出
整数溢出（Integer Overflow）是 C++ 中一个常见的、潜在的严重问题。当一个算术运算的结果超出该类型所能表示的最大或最小值时，就会发生溢出。有符号整数溢出和无符号整数溢出的行为是不同的，其中有符号整数溢出导致未定义行为（Undefined Behavior），这是极其危险的。
① 有符号整数溢出（Signed Integer Overflow）
▮▮▮▮当有符号整数运算产生的结果超出了该类型能表示的范围时，其行为是未定义（Undefined Behavior）的。
▮▮▮▮这意味着编译器可以自由地执行任何操作：程序可能会崩溃、产生错误的结果、或者似乎正常运行但带有隐藏的错误。你不能依赖任何特定的溢出行为，例如它环绕到负数。即使在大多数常见系统中它可能表现为环绕，这也不是标准保证的行为，不应该依赖。
▮▮▮▮未定义行为是 C++ 中最难调试的 bug 之一，因为它可能在不同的编译器、不同的优化级别、不同的运行时环境下表现出不同的症状，甚至在某些情况下根本不表现出来，直到某个特定的输入或环境触发它。
示例：
1
#include <iostream>
2
#include <limits> // For std::numeric_limits
3
4
int main() {
5
int max_int = std::numeric_limits<int>::max();
6
int large_number = 100;
7
8
std::cout << "Max int: " << max_int << std::endl;
9
10
// 潜在的有符号整数溢出：max_int + large_number > max_int
11
// 这可能导致未定义行为（Undefined Behavior）
12
int result = max_int + large_number;
13
14
// 输出的结果是不可预测的，可能是一个负数，或者其他意想不到的值
15
// 在很多系统上，二进制补码表示下可能会环绕到最小值附近的负数
16
// 但记住，这是 UB 的一种可能表现，不是保证的行为！
17
std::cout << "max_int + 100 = " << result << std::endl; // ⚠ Undefined Behavior here!
18
19
return 0;
20
}
▮▮▮▮在上述示例中，max_int + large_number 的结果超出了 int 的范围，这是有符号整数溢出，触发了未定义行为。编译器可能为了优化而假设有符号整数不会溢出，从而产生意想不到的代码。
② 无符号整数溢出（Unsigned Integer Overflow）
▮▮▮▮与有符号整数不同，无符号整数的溢出行为是良好定义（well-defined）的。
▮▮▮▮当无符号整数运算结果超出其范围时，结果会环绕（wrap around）。这意味着结果是模 \(2^N\) 的值，其中 N 是该无符号类型的位宽。
▮▮▮▮例如，一个 8 位的无符号整数（范围 0-255），如果计算结果是 256，实际存储的值是 \(256 \pmod{256} = 0\)；如果结果是 257，实际存储的值是 \(257 \pmod{256} = 1\)。
示例：
1
#include <iostream>
2
#include <limits> // For std::numeric_limits
3
4
int main() {
5
unsigned int max_uint = std::numeric_limits<unsigned int>::max();
6
unsigned int large_number = 100;
7
8
std::cout << "Max unsigned int: " << max_uint << std::endl;
9
10
// 无符号整数溢出：行为良好定义，结果会环绕
11
// 结果是 (max_uint + 100) % (max_uint + 1)
12
unsigned int result = max_uint + large_number; // Well-defined wrap-around
13
14
std::cout << "max_uint + 100 = " << result << std::endl; // 结果可预测
15
16
return 0;
17
}
③ 避免和检测整数溢出的策略
▮▮▮▮尽管无符号整数溢出是良好定义的，但它通常也不是你想要的结果。因此，避免所有类型的整数溢出是良好的编程实践。对于有符号整数，避免溢出更是强制性的，因为 UB 会破坏程序的可预测性。
策略包括：
⚝ 使用足够大的类型： 如果你知道数值可能很大，使用 long long 或 <cstdint> 中保证更大范围的类型（如 int64_t 或 uint64_t）。
⚝ 操作前进行范围检查： 在执行可能导致溢出的操作（如加法、减法、乘法）之前，检查操作数是否在不会导致溢出的范围内。
▮▮▮▮例如，对于有符号加法 a + b，如果 a > 0 且 b > 0，检查是否 a > std::numeric_limits<int>::max() - b。如果 a < 0 且 b < 0，检查是否 a < std::numeric_limits<int>::min() - b。
▮▮▮▮对于乘法 a * b，如果 a > 0 且 b > 0，检查是否 a > std::numeric_limits<int>::max() / b。需要考虑所有符号组合。
⚝ 使用编译器警告和静态分析工具： 现代编译器和静态分析工具可以检测出一些明显的溢出风险。开启相关的警告（如 GCC/Clang 的 -Woverflow, -Wuseless-cast, -Wsign-compare, -Wconversion）。
⚝ 使用检查溢出的库或函数： 一些库（如 Boost.SafeNumerics）提供了“安全”的数值类型，会在运行时检查溢出并抛出异常或采取其他处理方式。或者自己实现或使用检查溢出的辅助函数。C++20 标准引入了 std::add_signed 和 std::add_unsigned 等类型特性，配合 <limits> 可以编写更通用的检查函数。
⚝ 注意循环和迭代： 使用整数类型作为循环计数器或数组索引时，要特别小心边界条件，确保计数器不会溢出或与无符号索引混合导致问题（详见 Chapter 7）。例如，一个常见的错误是使用无符号整数作为循环变量，并在循环中递减到负数，这会导致意外的环绕和无限循环。
示例（操作前检查）：
1
#include <iostream>
2
#include <limits>
3
4
bool add_safe(int a, int b, int& result) {
5
if (a > 0 && b > 0 && a > std::numeric_limits<int>::max() - b) {
6
return false; // Overflow
7
}
8
if (a < 0 && b < 0 && a < std::numeric_limits<int>::min() - b) {
9
return false; // Underflow
10
}
11
result = a + b;
12
return true; // OK
13
}
14
15
int main() {
16
int a = std::numeric_limits<int>::max();
17
int b = 100;
18
int result;
19
20
if (add_safe(a, b, result)) {
21
std::cout << "Result of addition: " << result << std::endl;
22
} else {
23
std::cout << "Error: Integer overflow detected!" << std::endl; // ✅ 安全处理溢出
24
}
25
26
return 0;
27
}
这种操作前检查的方法虽然安全，但会增加代码的复杂度和运行时开销。在性能敏感的场景下需要权衡。
8.3 安全地进行类型转换
在 C++ 中，整数类型之间可以进行类型转换（Type Conversion），包括编译器自动进行的隐式类型转换（Implicit Type Conversion）和程序员主动请求的显式类型转换（Explicit Type Conversion），也称为强制类型转换（Casts）。类型转换是强大但危险的工具，不当的转换可能导致数据丢失、值改变甚至未定义行为。
① 隐式类型转换的陷阱
▮▮▮▮C++ 在许多场景下会自动进行隐式类型转换，例如：
▮▮▮▮算术运算中不同类型的操作数（发生算术转换）。
▮▮▮▮将小整数类型传递给需要 int 或更大类型的函数（发生整型提升）。
▮▮▮▮将表达式结果赋值给不同类型的变量。
▮▮▮▮将实参传递给函数形参，或从函数返回。
▮▮▮▮尽管隐式转换提供了便利，但它们可能导致意外的结果，特别是：
▮▮▮▮窄化转换（Narrowing Conversion）： 将范围或精度较大的类型转换为范围或精度较小的类型，可能导致数据丢失。例如，将 long long 转换为 int，或者将无符号类型转换为有符号类型，如果原始值超出目标类型的范围。
▮▮▮▮有符号与无符号混合运算/比较： 如 Chapter 7 所述，当有符号类型与无符号类型一起使用时，通常有符号类型会隐式转换为无符号类型，这可能导致非直觉的结果，特别是涉及到负数时。
示例（隐式转换陷阱）：
1
#include <iostream>
2
3
int main() {
4
long long big_value = 5000000000LL; // 50亿，超出 32 位 int 范围
5
int small_value = big_value; // ⚠ 窄化转换，数据丢失！隐式发生
6
7
std::cout << "Original long long: " << big_value << std::endl;
8
std::cout << "Converted int: " << small_value << std::endl; // 输出结果不等于 50亿
9
10
unsigned int u = 10;
11
int i = -1;
12
13
// ⚠ 有符号与无符号比较，i 会被转换为无符号类型
14
// 在二进制补码表示下，-1 的无符号表示是该类型能表示的最大值
15
if (i < u) {
16
std::cout << "-1 is less than 10 (signed comparison)" << std::endl;
17
} else {
18
// 实际执行的是 (unsigned int)i < u
19
// (unsigned int)-1 通常是 UINT_MAX，而 UINT_MAX > 10
20
std::cout << "-1 is NOT less than 10 (unsigned comparison due to implicit conversion)" << std::endl; // ✅ 打印这行
21
}
22
23
return 0;
24
}
② 推荐使用显式类型转换 (static_cast)
▮▮▮▮为了提高代码的清晰度和安全性，推荐在需要类型转换时使用 C++ 风格的显式类型转换，特别是 static_cast。
▮▮▮▮static_cast<TargetType>(expression) 用于执行类型之间相关的、非多态的转换，包括整数类型之间的转换。
▮▮▮▮使用 static_cast 的好处在于：
▮▮▮▮意图明确： 它清楚地表明了程序员在这里是故意进行类型转换的。
▮▮▮▮编译器检查： static_cast 会进行一些编译时检查，可以捕获一些不安全的或无意义的转换（尽管它不能阻止所有窄化转换）。
▮▮▮▮易于查找： 在代码中搜索 static_cast 可以快速找到所有显式转换点，便于代码审查和理解。
示例 (static_cast):
1
#include <iostream>
2
#include <cstdint> // For int64_t
3
4
int main() {
5
int64_t big_value = 5000000000LL;
6
7
// 使用 static_cast 进行显式转换
8
// ⚠ 仍然是窄化转换，但意图明确
9
int small_value = static_cast<int>(big_value);
10
11
std::cout << "Original int64_t: " << big_value << std::endl;
12
std::cout << "Converted int: " << small_value << std::endl; // 数据仍然丢失
13
14
unsigned int u = 10;
15
int i = -1;
16
17
// 显式转换为有符号类型再比较，或者根据需要显式转换为无符号
18
// 如果你的意图是有符号比较：
19
if (i < static_cast<int>(u)) { // ⚠ 警告：unsigned 转 signed 可能丢失信息
20
std::cout << "-1 is less than 10 (explicit signed comparison)" << std::endl; // ✅ 打印这行 (如果 10 在 int 范围内)
21
}
22
23
// 如果你的意图是无符号比较：
24
if (static_cast<unsigned int>(i) < u) {
25
std::cout << "-1 is less than 10 (explicit unsigned comparison)" << std::endl;
26
} else {
27
std::cout << "-1 is NOT less than 10 (explicit unsigned comparison)" << std::endl; // ✅ 打印这行
28
}
29
30
31
return 0;
32
}
这个例子展示了 static_cast 如何明确转换意图，即使窄化转换仍然发生，我们也意识到了这一点。对于有符号/无符号比较，显式转换可以强制执行你想要的比较逻辑。
③ 进行范围检查（Range Checking）
▮▮▮▮仅仅使用 static_cast 并不能阻止窄化转换导致的数据丢失。最安全的做法是在进行可能导致窄化的显式转换之前，先检查源数值是否在目标类型的范围内。
▮▮▮▮可以使用 <limits> 头文件中的 std::numeric_limits 来获取类型的最大最小值进行检查。
示例（带范围检查的转换）：
1
#include <iostream>
2
#include <limits>
3
#include <cstdint>
4
5
int main() {
6
int64_t big_value = 5000000000LL;
7
// int64_t big_value = 100; // 试试一个在 int 范围内的值
8
9
if (big_value >= std::numeric_limits<int>::min() &&
10
big_value <= std::numeric_limits<int>::max()) {
11
int small_value = static_cast<int>(big_value);
12
std::cout << "Value " << big_value << " is within int range." << std::endl;
13
std::cout << "Converted int: " << small_value << std::endl; // 安全转换
14
} else {
15
std::cerr << "Error: Value " << big_value << " is out of int range. Conversion would lose data." << std::endl; // ✅ 发现问题并报告
16
// 根据情况选择错误处理：抛异常、返回错误码等
17
}
18
19
return 0;
20
}
这种方法虽然最安全，但会增加代码量和运行时检查开销。在性能关键或对数值范围有严格保证的场景外，结合良好的设计、编译器警告以及代码审查，可以决定是否需要如此细致的检查。对于从用户输入或外部源获取的数值，进行范围检查尤其重要。
8.4 使用无符号类型时的注意事项
无符号整数类型是 C++ 强大的特性之一，特别适用于表示非负数量和进行位操作。然而，它们也有一些独特的行为，如果不加以注意，可能会引入微妙的错误。
① 适用于非负值的表示
▮▮▮▮无符号类型（如 unsigned int, size_t）是表示非负数量（如数组/容器大小、计数、索引）的理想选择。这清晰地表达了变量的用途，并且对于相同位宽，其最大可表示值是有符号类型的大约两倍。
▮▮▮▮标准库容器的 size() 方法返回 size_t，就是一个无符号类型，这强调了容器大小是非负的。
② 理解环绕行为（Wrap-around）
▮▮▮▮无符号整数的溢出是定义好的环绕行为。这意味着当结果超出最大值时，会从零开始重新计数（模 \(2^N\) 运算）。当结果小于零时（例如，无符号数相减，被减数小于减数），结果会环绕到最大值附近。
▮▮▮▮虽然这在某些底层编程（如哈希计算、校验和）中可能被有意利用，但在大多数常规数值计算中，环绕行为通常意味着逻辑错误。
示例（无符号环绕）：
1
#include <iostream>
2
#include <limits>
3
4
int main() {
5
unsigned int u1 = 10;
6
unsigned int u2 = 20;
7
8
// u1 - u2 = 10 - 20 = -10
9
// 对于无符号类型，结果是 -10 模 2^N
10
// 相当于 UINT_MAX + 1 - 10
11
unsigned int result_sub = u1 - u2;
12
std::cout << "10U - 20U = " << result_sub << std::endl; // 输出一个非常大的正数
13
14
unsigned int u3 = std::numeric_limits<unsigned int>::max();
15
unsigned int u4 = 1;
16
unsigned int result_add = u3 + u4; // 溢出，环绕到 0
17
std::cout << "UINT_MAX + 1U = " << result_add << std::endl; // 输出 0
18
19
return 0;
20
}
③ 与有符号整数的交互
▮▮▮▮这是使用无符号类型最常见的陷阱之一。当无符号和有符号整数混合参与运算或比较时，有符号操作数通常会被隐式转换为无符号类型。
▮▮▮▮如 Chapter 7 详细讨论的，这种转换规则可能导致比较和算术运算产生反直觉的结果，特别是当有符号数是负数时。负数的无符号表示是一个非常大的正数。
示例（无符号与有符号交互）：
1
#include <iostream>
2
3
int main() {
4
unsigned int count = 5;
5
int threshold = -1;
6
7
// ⚠ 危险：有符号数 threshold (-1) 被隐式转换为无符号数
8
// (unsigned int)-1 通常是 UINT_MAX
9
if (count > threshold) {
10
// 实际比较的是 5 > UINT_MAX，结果为假
11
std::cout << "5 is greater than -1 (signed comparison)" << std::endl;
12
} else {
13
std::cout << "5 is NOT greater than -1 (unsigned comparison due to implicit conversion)" << std::endl; // ✅ 打印这行
14
}
15
16
// 另一个例子：在循环中使用无符号索引和有符号界限
17
std::vector<int> data = {1, 2, 3};
18
// 假设 data.size() 返回 3U
19
for (unsigned int i = data.size() - 1; i >= 0; --i) { // ⚠ 危险的循环条件
20
// 当 i 递减到 0 时，下一轮 i 成为 0U - 1U，环绕为 UINT_MAX
21
// 然后 i >= 0 (即 UINT_MAX >= 0U) 仍然为真，导致无限循环
22
std::cout << "Processing element at index: " << i << std::endl;
23
if (i == 0) break; // 必须有额外的退出条件，否则无限循环！
24
} // 这里的循环逻辑是错误的，应该使用有符号类型进行递减循环，或者特殊处理边界
25
26
return 0;
27
}
④ 最佳实践
⚝ 仅在必要时使用无符号类型： 将无符号类型的使用限制在表示非负数量或进行位操作的场景。
⚝ 避免无符号与有符号混合使用： 尽量避免在同一个表达式或比较中使用无符号和有符号整数。如果必须混合使用，请使用显式类型转换（static_cast）来明确意图，并注意可能的范围问题。
⚝ 警惕无符号循环： 在使用无符号整数作为循环计数器时，特别是涉及递减或复杂的终止条件时，要格外小心环绕行为。考虑使用有符号整数进行循环，或者确保循环逻辑能够正确处理无符号类型的边界。一个常见的模式是使用 size_t 进行递增循环，并与 container.size() 比较。对于递减循环，有时更安全的是使用有符号类型，或者从 size()-1 开始，循环条件为 i < size() 或 i >= 0（但要小心，因为无符号数 i >= 0 总是真）。更安全的递减循环通常涉及将循环变量与 0 进行比较，并在其到达 0 时特殊处理或退出。
8.5 利用编译器警告
编译器是你的好帮手！现代 C++ 编译器（如 GCC, Clang, MSVC）提供了丰富的警告选项，可以帮助你发现代码中潜在的问题，包括许多与整数类型使用不当相关的陷阱，如类型转换问题、有符号/无符号不匹配、潜在的溢出等。
① 开启尽可能多的警告
▮▮▮▮不要害怕警告。警告提示你的代码中可能存在逻辑错误、未定义行为或可移植性问题。虽然不是所有警告都指示着致命错误，但认真对待它们，理解其含义并修正代码，可以显著提高代码质量和健壮性。
▮▮▮▮推荐在开发过程中使用严格的警告级别。常用的警告 flag 包括：
▮▮▮▮GCC/Clang: -Wall, -Wextra (开启大部分常见警告)，-Wpedantic (遵循标准严格检查)，-Wconversion (警告可能改变值的隐式转换)，-Wsign-compare (警告有符号/无符号比较)，-Woverflow (警告常量表达式中的溢出)。
▮▮▮▮MSVC: /W4 (较高的警告级别)，/permissive- (更严格遵循标准)，/sdl (Security Development Lifecycle checks，包含一些数值安全检查)。
▮▮▮▮这些警告选项应添加到你的编译命令或构建系统配置中。
示例（编译器警告）：
考虑以下代码：
1
#include <iostream>
2
3
int main() {
4
int a = 10;
5
unsigned int b = 20;
6
7
if (a - b < 0) { // ⚠ 潜在警告：有符号/无符号混合运算/比较
8
std::cout << "a - b is negative" << std::endl;
9
} else {
10
std::cout << "a - b is not negative" << std::endl;
11
}
12
13
int max_val = 2147483647; // INT_MAX for 32-bit int
14
int result = max_val + 1; // ⚠ 潜在警告：有符号整数溢出
15
16
return 0;
17
}
使用 g++ -Wall -Wextra -Wconversion -Wsign-compare -Woverflow your_code.cpp 编译，你可能会收到类似以下的警告：
1
your_code.cpp: In function 'int main()':
2
your_code.cpp:7:14: warning: comparison of integer expressions of different signedness: 'int' and 'unsigned int' [-Wsign-compare]
3
7 | if (a - b < 0) {
4
| ~~~~^~~~~
5
your_code.cpp:13:23: warning: integer overflow in expression [-Woverflow]
6
13 | int result = max_val + 1;
7
| ~~~^~~~
第一个警告提示你在比较不同有符号性的整数类型，这可能导致意外结果。第二个警告直接指出了常量表达式中的整数溢出（尽管对于非常量表达式的运行时溢出，编译器通常无法警告）。
② 将警告视为错误
▮▮▮▮一旦你的代码在特定警告级别下没有警告，可以考虑在持续集成或发布构建中将编译器警告视为错误。
▮▮▮▮GCC/Clang 的 flag 是 -Werror。MSVC 的 flag 是 /WX。
▮▮▮▮这样做可以防止新的代码提交引入新的警告，强制开发人员立即修复警告，保证代码库的健康。
③ 理解并解决警告
▮▮▮▮仅仅开启警告是不够的，更重要的是理解每个警告的含义，并采取适当的措施解决它。
▮▮▮▮对于类型转换相关的警告，通常的解决方案是使用显式转换（如 static_cast）来消除警告并明确你的意图。如果转换涉及窄化，并且这是预期的行为，可以使用显式转换并可能添加注释说明。如果窄化是错误的，则需要修改逻辑或使用更大的类型。
▮▮▮▮对于有符号/无符号比较警告，明确你是想进行有符号比较还是无符号比较，然后使用 static_cast 将其中一个操作数显式转换为另一种类型，使其类型匹配。
总结：
利用编译器警告是提高代码质量最经济有效的方法之一。在开发流程中尽早开启并解决警告，可以将许多潜在的整数类型相关问题消灭在萌芽状态。🧑🏫
9. 高级主题与特定用途整数类型
本章将深入探讨 C++ 中一些更高级或用于特定目的的整数类型和相关的概念。这些内容对于编写需要精确控制内存布局、进行位级别操作或确保跨平台兼容性的代码至关重要。我们将介绍固定宽度整数类型、size_t 和 ptrdiff_t、位字段，并简要讨论字节序对整数表示的影响。理解这些主题将帮助您更深入地掌握 C++ 整数类型在实际编程中的应用，特别是在系统级或性能敏感的场景下。
9.1 固定宽度整数类型（Fixed-width Integer Types, C++11+）
C++ 标准的基本整数类型（如 int, long）只规定了它们的最小范围，而实际的大小（位宽）是平台和编译器相关的。这在需要精确控制数据大小（例如，与硬件交互、网络通信、文件格式）的场景下带来了可移植性问题。为了解决这个问题，C++11 标准引入了固定宽度整数类型，定义在 <cstdint> 头文件中。这些类型根据它们的位宽命名，提供了更强的可移植性和精确性。
9.1.1 确切宽度类型（Exact-width Types）
确切宽度类型保证具有指定的位宽（不包括符号位）。如果一个平台支持某个确切宽度类型的整数，那么它的位宽就是精确的 N 位。这些类型是可选的，也就是说，并不是所有平台都必须提供所有确切宽度类型。
⚝ intN_t: 有符号整数类型，精确宽度为 N 位。例如：int8_t, int16_t, int32_t, int64_t。
⚝ uintN_t: 无符号整数类型，精确宽度为 N 位。例如：uint8_t, uint16_t, uint32_t, uint64_t。
特性:
⚝ 如果存在，保证位宽为 N。
⚝ 对于 \( N \in \{8, 16, 32, 64\} \)，如果平台支持，则这些类型必须存在。对于其他 N 值，它们的存在是可选的。
⚝ 常用于需要与外部接口（硬件、网络协议、文件格式）精确匹配数据大小的场景。
示例:
1
#include <cstdint>
2
#include <iostream>
3
4
int main() {
5
// 如果平台支持，这些类型的大小是固定的
6
int32_t signed_32bit = -123456789;
7
uint64_t unsigned_64bit = 9876543210ULL;
8
9
std::cout << "Size of int32_t: " << sizeof(int32_t) << " bytes\n";
10
std::cout << "Size of uint64_t: " << sizeof(uint64_t) << " bytes\n";
11
// 请注意：sizeof 返回的是字节数，1 byte = 8 bits
12
// 如果存在 int32_t，sizeof(int32_t) 应该等于 4
13
// 如果存在 uint64_t，sizeof(uint64_t) 应该等于 8
14
15
return 0;
16
}
9.1.2 最小宽度类型（Minimum-width Types）
最小宽度类型保证其位宽至少为指定的 N 位。如果一个平台不支持精确宽度为 N 位的整数类型，但支持位宽大于 N 的类型，那么最小宽度类型将选择满足条件的最小位宽类型。这些类型总是存在的。
⚝ int_leastN_t: 有符号整数类型，位宽至少为 N 位。
⚝ uint_leastN_t: 无符号整数类型，位宽至少为 N 位。
特性:
⚝ 保证位宽 至少 为 N。
⚝ 对于 \( N \in \{8, 16, 32, 64\} \)，这些类型总是存在的。
⚝ 常用于只需要保证数值范围足够大，对精确位宽没有严格要求的场景。
示例:
1
#include <cstdint>
2
#include <iostream>
3
4
int main() {
5
// int_least32_t 可能是 int32_t, long, 或 long long
6
// 取决于哪个是第一个满足至少 32 位宽度的类型
7
int_least32_t value = 100000;
8
9
std::cout << "Size of int_least32_t: " << sizeof(int_least32_t) << " bytes\n";
10
std::cout << "Value: " << value << std::endl;
11
12
return 0;
13
}
9.1.3 最快最小宽度类型（Fastest minimum-width types）
最快最小宽度类型保证其位宽至少为指定的 N 位，并且是系统中对该位宽操作最快的整数类型。选择哪个类型作为“最快”是实现定义的。这些类型总是存在的。
⚝ int_fastN_t: 有符号整数类型，位宽至少为 N 位，且操作最快。
⚝ uint_fastN_t: 无符号整数类型，位宽至少为 N 位，且操作最快。
特性:
⚝ 保证位宽 至少 为 N。
⚝ 保证是满足位宽要求中操作最快的类型（实现定义）。
⚝ 对于 \( N \in \{8, 16, 32, 64\} \)，这些类型总是存在的。
⚝ 常用于对性能有较高要求，同时需要保证最小数值范围的场景。
示例:
1
#include <cstdint>
2
#include <iostream>
3
4
int main() {
5
// int_fast16_t 可能是 int16_t, int, 或其他在当前平台上最快的类型
6
int_fast16_t counter = 0;
7
8
std::cout << "Size of int_fast16_t: " << sizeof(int_fast16_t) << " bytes\n";
9
// 在某些系统上，即使 int 是 32 位，它可能比 16 位的 int16_t 操作更快，
10
// 此时 int_fast16_t 可能是 int。
11
12
return 0;
13
}
9.1.4 指针宽度类型（Pointer-width Types）
指针宽度类型是足以存储任何数据指针（void*）值的整数类型。它们的大小通常与系统的指针大小相同。这些类型是可选的。
⚝ intptr_t: 有符号整数类型，足以存储 void*。
⚝ uintptr_t: 无符号整数类型，足以存储 void*。
特性:
⚝ 能够存储 void* 的值，通常用于将指针转换为整数进行某些操作（例如，对齐计算），然后再转换回指针。
⚝ 存在性是可选的。
⚝ 警告：将指针转换为整数或反之是低级操作，应谨慎使用，并理解其潜在的平台依赖性和未定义行为（例如，转换为足够大的整数类型是必要的，但并非所有系统都保证 intptr_t 或 uintptr_t 能够完全存储任何指针值，尽管现代系统通常如此）。
示例:
1
#include <cstdint>
2
#include <iostream>
3
4
int main() {
5
int value = 42;
6
int* ptr = &value;
7
8
// 将指针转换为 uintptr_t
9
uintptr_t ptr_as_int = reinterpret_cast<uintptr_t>(ptr);
10
11
std::cout << "Pointer address: " << ptr << std::endl;
12
std::cout << "Pointer as integer: " << std::hex << ptr_as_int << std::dec << std::endl;
13
14
// 从整数转换回指针 (需要谨慎)
15
int* another_ptr = reinterpret_cast<int*>(ptr_as_int);
16
std::cout << "Integer back to pointer: " << another_ptr << std::endl;
17
std::cout << "Value via another_ptr: " << *another_ptr << std::endl;
18
19
return 0;
20
}
9.1.5 最大宽度类型（Greatest-width Types）
最大宽度类型是能够存储任何其他标准整数类型值的类型。它们通常是平台支持的最大整数类型（例如，long long 或 unsigned long long）。这些类型总是存在的。
⚝ intmax_t: 有符号整数类型，能够存储任何有符号标准整数类型的值。
⚝ uintmax_t: 无符号整数类型，能够存储任何无符号标准整数类型的值。
特性:
⚝ 保证能够表示所有标准整数类型（包括基本类型和 <cstdint> 中的其他类型）的最大可能值。
⚝ 总是存在的。
⚝ 常用于通用处理各种整数值的函数或模板参数。
示例:
1
#include <cstdint>
2
#include <iostream>
3
#include <limits>
4
5
int main() {
6
intmax_t max_signed_val = std::numeric_limits<intmax_t>::max();
7
uintmax_t max_unsigned_val = std::numeric_limits<uintmax_t>::max();
8
9
std::cout << "Maximum value of intmax_t: " << max_signed_val << std::endl;
10
std::cout << "Maximum value of uintmax_t: " << max_unsigned_val << std::endl;
11
12
return 0;
13
}
9.2 size_t 和 ptrdiff_t
size_t 和 ptrdiff_t 是 C++ 标准库中定义的两个重要整数类型，它们不是基本类型，但在处理内存、数组和指针时极为常用。它们通常定义在 <cstddef> 头文件中。
size_t
⚝ 用途: size_t 是一种无符号整数类型，用于表示对象的大小（以字节为单位）和数组的索引。它是 sizeof 运算符的返回类型。
⚝ 特性:
⚝ 无符号类型，因此不能表示负值。
⚝ 保证能够表示任何对象的大小。在 64 位系统上通常是 64 位无符号整数，在 32 位系统上通常是 32 位无符号整数。
⚝ 主要用于容器的大小、内存分配函数的参数（如 malloc）和返回类型、循环计数器（特别是遍历容器时）。
⚝ 潜在陷阱:
⚝ 与有符号整数混合运算或比较时，可能导致意外的无符号转换行为（参见第 7 章）。例如，std::vector<int> v; size_t s = v.size(); int index = -1; if (index < s) 这个条件在 s 很大时可能为真，因为 index 会被转换为无符号类型。
⚝ 不应用于表示可能为负的值。
示例:
1
#include <cstddef> // For size_t
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
std::vector<int> data = {10, 20, 30, 40};
7
8
// 使用 size_t 表示容器大小
9
size_t container_size = data.size();
10
std::cout << "Container size: " << container_size << std::endl;
11
std::cout << "Size of size_t: " << sizeof(size_t) << " bytes" << std::endl;
12
13
// 使用 size_t 作为循环索引
14
for (size_t i = 0; i < data.size(); ++i) {
15
std::cout << "Element at index " << i << ": " << data[i] << std::endl;
16
}
17
18
// 潜在的陷阱：有符号与无符号比较
19
int signed_index = -1;
20
if (signed_index < container_size) { // signed_index 被提升/转换为无符号类型
21
std::cout << "(-1 < " << container_size << ") is true due to unsigned conversion." << std::endl;
22
} else {
23
std::cout << "(-1 < " << container_size << ") is false." << std::endl;
24
}
25
26
27
return 0;
28
}
ptrdiff_t
⚝ 用途: ptrdiff_t 是一种有符号整数类型，用于表示两个指针之间的差值（元素的数量）。它是对同一数组或内存块中两个指针相减的结果类型。
⚝ 特性:
⚝ 有符号类型，可以表示正向或反向的差值。
⚝ 保证能够表示同一数组中任意两个元素指针的差值。其大小通常与 size_t 相同，但因为是有符号的，其范围是 \( [-\text{MAX}, +\text{MAX}] \) 而不是 \( [0, \text{MAX_2}] \)，其中 MAX 可能略小于 MAX_2。
⚝ 主要用于指针算术的结果。
⚝ 限制:
⚝ 只有指向同一数组或同一对象（以及对象末尾之后一个位置）的指针相减的结果是明确定义的。对不相关指针相减的结果是未定义行为。
示例:
1
#include <cstddef> // For ptrdiff_t
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
std::vector<int> data = {10, 20, 30, 40, 50};
7
8
int* ptr1 = &data[1]; // Pointing to 20
9
int* ptr2 = &data[4]; // Pointing to 50
10
11
// 计算两个指针之间的差值
12
ptrdiff_t diff = ptr2 - ptr1; // (address of data[4] - address of data[1]) / sizeof(int)
13
14
std::cout << "ptr1 points to: " << *ptr1 << std::endl;
15
std::cout << "ptr2 points to: " << *ptr2 << std::endl;
16
std::cout << "Difference between ptr2 and ptr1 (number of elements): " << diff << std::endl; // Expected output: 3
17
std::cout << "Size of ptrdiff_t: " << sizeof(ptrdiff_t) << " bytes" << std::endl;
18
19
// 负数差值
20
ptrdiff_t diff2 = ptr1 - ptr2;
21
std::cout << "Difference between ptr1 and ptr2: " << diff2 << std::endl; // Expected output: -3
22
23
24
return 0;
25
}
9.3 位字段（Bit Fields）
位字段是一种特殊的类成员声明（通常在 struct 或 union 中），它允许指定成员的位宽。这使得在结构体或联合体中可以紧凑地存储数据，甚至可以存储小于一个字节的数据项。位字段常用于：
⚝ 需要精确控制内存布局，以节省空间。
⚝ 映射到硬件寄存器的特定位。
⚝ 实现某些紧凑的数据结构或协议格式。
语法:
在结构体或联合体成员声明后，使用冒号 : 跟着一个整数常量表达式，表示该位字段的位宽。
1
struct Settings {
2
unsigned int flag1 : 1; // 1 bit
3
unsigned int flag2 : 1; // 1 bit
4
unsigned int mode : 2; // 2 bits
5
unsigned int value : 5; // 5 bits
6
// 总共 1 + 1 + 2 + 5 = 9 bits
7
// 实际占用的内存可能不止 9 bits，取决于对齐和实现
8
};
特性与注意事项:
⚝ 内存布局: 位字段在内存中的具体布局（例如，是从低位到高位还是从高位到低位填充）是实现定义的。这意味着位字段的内存表示不可移植。
⚝ 对齐: 尽管位字段允许按位分配，但整个结构体仍然需要遵循一定的对齐规则。编译器可能会在位字段之间或之后插入填充位（padding bits）以满足对齐要求，这可能会导致实际占用的字节数大于所有位字段的总位宽除以 8。
⚝ 类型: 位字段的类型必须是整数类型（如 unsigned int, signed int, int, bool）。不能是数组、指针、浮点类型等。C++ 标准允许 bool 作为位字段类型。从 C++11 起，允许使用固定宽度整数类型（如 uint8_t）作为位字段的基础类型，但这并不能保证位字段本身的大小就是精确的 N 位，它只是决定了位字段能够存储的最大值和符号行为。
⚝ 匿名位字段: 可以声明没有名字的位字段，用于在位字段之间插入填充位。例如：unsigned int AlBeRt63EiNsTeIn 0;）可以强制下一个位字段从下一个分配单元（通常是基础类型的大小，如下一个 unsigned int 的边界）开始。
⚝ 限制: 不能获取位字段的地址（因此不能有指向位字段的指针或引用）。位字段不能是静态成员。
示例:
1
#include <iostream>
2
#include <cstdint> // C++11 onwards, can use fixed-width types
3
4
// 定义一个包含位字段的结构体
5
struct PacketHeader {
6
uint8_t version : 4; // 4 bits
7
uint8_t type : 4; // 4 bits
8
uint8_t flags : 3; // 3 bits
9
uint8_t : 5; // 5 bits of padding to fill the second byte
10
uint16_t length; // 16 bits (2 bytes)
11
// Total: 4 + 4 + 3 + 5 bits + 16 bits = 8 bits + 16 bits = 3 bytes (potentially, depends on alignment)
12
};
13
14
int main() {
15
PacketHeader header;
16
header.version = 5;
17
header.type = 1;
18
header.flags = 7; // Max value for 3 bits is 2^3 - 1 = 7
19
header.length = 256;
20
21
std::cout << "Size of PacketHeader struct: " << sizeof(PacketHeader) << " bytes" << std::endl;
22
std::cout << "Version: " << (unsigned int)header.version << std::endl;
23
std::cout << "Type: " << (unsigned int)header.type << std::endl;
24
std::cout << "Flags: " << (unsigned int)header.flags << std::endl;
25
std::cout << "Length: " << header.length << std::endl;
26
27
// 注意：尝试访问 padding 位字段是无效的
28
// std::cout << "Padding: " << (unsigned int)header. : 5 << std::endl; // Error
29
30
return 0;
31
}
在这个例子中，PacketHeader 的 sizeof 可能不是精确的 3 字节，因为结构体本身的对齐要求可能会使其填充到 4 字节或更大。位字段主要优化的是结构体内部成员的存储空间，而不是整个结构体的 sizeof。
9.4 字节序（Endianness）对整数表示的影响
字节序是指在多字节数据类型（如 16 位、32 位、64 位整数）存储在内存中时，字节的排列顺序。C++ 标准没有规定字节序，它是平台相关的特性。理解字节序对于处理二进制文件、网络通信或跨平台数据交换非常重要。
主要有两种字节序：
① 大端序（Big-Endian）：将数据的最高有效字节（Most Significant Byte, MSB）存储在内存的最低地址处，最低有效字节（Least Significant Byte, LSB）存储在最高地址处。这就像我们书写数字时从左到右（高位到低位）的顺序。网络协议通常使用大端序（网络字节序）。
② 小端序（Little-Endian）：将数据的最低有效字节（LSB）存储在内存的最低地址处，最高有效字节（MSB）存储在最高地址处。这是目前大多数个人计算机（x86, x64 架构）使用的字节序。
示例:
假设有一个 32 位无符号整数 0x12345678。它由四个字节组成：0x12, 0x34, 0x56, 0x78，其中 0x12 是 MSB，0x78 是 LSB。
⚝ 在大端序系统中，它在内存中的存储顺序（从低地址到高地址）将是：
1
地址 N: 0x12 (MSB)
2
地址 N+1: 0x34
3
地址 N+2: 0x56
4
地址 N+3: 0x78 (LSB)
⚝ 在小端序系统中，它在内存中的存储顺序（从低地址到高地址）将是：
1
地址 N: 0x78 (LSB)
2
地址 N+1: 0x56
3
地址 N+2: 0x34
4
地址 N+3: 0x12 (MSB)
影响:
⚝ 二进制文件: 如果您在一个字节序的机器上写入一个二进制文件，并在另一个字节序的机器上读取它，多字节整数的值将会被错误地解释。
⚝ 网络通信: 不同机器可能使用不同的字节序。在网络通信中，发送方和接收方必须就数据格式达成一致。TCP/IP 协议族规定使用大端序作为网络字节序。因此，在发送数据前，需要将主机字节序转换为网络字节序（通常使用 htonl, htons 等函数），接收数据后，再从网络字节序转换回主机字节序（通常使用 ntohl, ntohs 等函数）。
⚝ 类型转换与位操作: 当通过指针或联合体重新解释内存中的字节序列时，字节序会影响结果。例如，将 char* 转换为 int* 读取多字节整数时，字节的解释顺序取决于字节序。
C++ 本身没有直接提供获取当前系统字节序或进行字节序转换的标准方法（C++20 在 <bit> 头文件中提供了一些相关工具，如 std::endian 枚举和字节序转换函数，但这取决于编译器和库的支持）。在 C++11/14/17 中，通常需要依赖操作系统提供的函数或手动进行位操作和字节重排来实现字节序转换。
了解字节序对于编写可移植的低级代码至关重要。在处理外部二进制数据时，总是需要明确数据源的字节序，并根据需要进行转换。
10. C++ 标准演进中的整数类型相关特性
摘要： 本章回顾 C++11 以来，标准对整数类型支持的改进和新增特性。这些演进旨在提高代码的可移植性、可读性和安全性，并提供对底层表示更精确的控制。
10.1 C++11: 固定宽度整数与 <cstdint>
摘要： 介绍 C++11 中引入的固定宽度整数类型，它们解决了不同平台下标准整数类型大小不确定的问题。
在 C++11 之前，标准只规定了基本整数类型（如 int, long）的最小范围要求，但没有规定其精确的位宽。例如，int 可能在 16 位系统上是 16 位，在 32 位系统上是 32 位，在 64 位系统上可能是 32 位或 64 位。这种可变的大小给需要精确控制数据位宽的应用程序（如网络编程、二进制文件读写、加密算法实现、与硬件交互）带来了可移植性问题。
为了解决这一问题，C++11 引入了 <cstdint> 头文件，定义了一系列具有固定位宽的整数类型。这些类型是可选的，只有当特定平台支持时才会定义，但大多数现代平台都支持它们。
固定宽度整数类型分类：
这些类型命名遵循 [signed/unsigned][width]_t 或 [signed/unsigned]_[property][width]_t 的模式。
① 确切宽度类型（Exact-width Types）
▮▮▮▮摘要： 如 intN_t, uintN_t，保证特定位宽。
▮▮▮▮这些类型保证是 N 位宽的有符号或无符号整数。例如，int32_t 保证是 32 位有符号整数，uint64_t 保证是 64 位无符号整数。只有当平台精确支持 N 位宽的整数类型时，这些类型才会被定义。
▮▮▮▮常见的确切宽度类型包括：
▮▮▮▮⚝ int8_t, uint8_t
▮▮▮▮⚝ int16_t, uint16_t
▮▮▮▮⚝ int32_t, uint32_t
▮▮▮▮⚝ int64_t, uint64_t
1
#include <cstdint>
2
#include <iostream>
3
#include <limits>
4
5
int main() {
6
std::int32_t a = 123456789; // 保证是 32 位有符号整数
7
std::uint64_t b = 0xFFFFFFFFFFFFFFFFULL; // 保证是 64 位无符号整数
8
9
std::cout << "sizeof(std::int32_t): " << sizeof(std::int32_t) << " bytes" << std::endl;
10
std::cout << "sizeof(std::uint64_t): " << sizeof(std::uint64_t) << " bytes" << std::endl;
11
std::cout << "std::uint64_t max value: " << std::numeric_limits<std::uint64_t>::max() << std::endl;
12
13
return 0;
14
}
② 最小宽度类型（Minimum-width Types）
▮▮▮▮摘要： 如 int_leastN_t, uint_leastN_t，保证至少特定位宽。
▮▮▮▮这些类型保证至少有 N 位宽。如果平台不支持精确 N 位的类型，它会选择大于 N 位且能表示 N 位所有值的最小可用类型。
▮▮▮▮例如，int_least32_t 保证至少 32 位宽。如果平台没有 32 位整数，但有 64 位整数，那么 int_least32_t 可能会是 64 位整数类型。
▮▮▮▮常见的最小宽度类型包括：
▮▮▮▮⚝ int_least8_t, uint_least8_t
▮▮▮▮⚝ int_least16_t, uint_least16_t
▮▮▮▮⚝ int_least32_t, uint_least32_t
▮▮▮▮⚝ int_least64_t, uint_least64_t
③ 最快最小宽度类型（Fastest minimum-width types）
▮▮▮▮摘要： 如 int_fastN_t, uint_fastN_t，在保证最小位宽的前提下提供最快操作。
▮▮▮▮这些类型也保证至少有 N 位宽，但编译器会选择在特定平台上处理速度最快的类型。例如，在 64 位系统上，即使 int 是 32 位，int_fast32_t 也可能被定义为 64 位的 long long，因为 64 位操作可能更快。
▮▮▮▮常见的最快最小宽度类型包括：
▮▮▮▮⚝ int_fast8_t, uint_fast8_t
▮▮▮▮⚝ int_fast16_t, uint_fast16_t
▮▮▮▮⚝ int_fast32_t, uint_fast32_t
▮▮▮▮⚝ int_fast64_t, uint_fast64_t
④ 指针宽度类型（Pointer-width Types）
▮▮▮▮摘要： 如 intptr_t, uintptr_t，足以存储指针值的整数类型。
▮▮▮▮这些类型的大小足以持有任何 void* 指针的值。这对于需要在整数类型和指针类型之间进行转换的底层代码（例如，哈希函数、某些数据结构的实现）非常有用。uintptr_t 通常用于无符号表示内存地址。
⑤ 最大宽度类型（Greatest-width Types）
▮▮▮▮摘要： 如 intmax_t, uintmax_t，能存储任何整数类型值的类型。
▮▮▮▮这些类型是平台上能够表示所有其他标准整数类型（包括固定宽度类型）的最大有符号和无符号整数类型。它们通常用于存储或处理来自不同整数类型的可能的最大值。
引入 <cstdint> 的意义：
⚝ 提高可移植性： 开发者可以指定精确的整数位宽，减少因平台差异导致的行为不一致。
⚝ 意图明确： 使用 int32_t 或 uint64_t 比使用 int 或 long long 更清楚地表达了变量的预期大小和用途。
⚝ 底层编程需求： 对于需要严格控制数据布局和大小的系统级或硬件相关编程至关重要。
10.2 C++14: 二进制字面量与数字分隔符
摘要： 介绍 C++14 新增的二进制字面量和数字分隔符，它们提高了代码的可读性。
在处理位操作、标志位或表示二进制数据时，直接使用二进制形式书写整数字面量可以极大地提高代码的可读性和清晰度。在 C++14 之前，通常只能通过八进制（前缀 0）或十六进制（前缀 0x 或 0X）来间接表示，或者使用位移和组合操作，这很不直观。
C++14 引入了二进制字面量。
二进制字面量（Binary Literals）：
⚝ 使用 0b 或 0B 作为前缀，后跟二进制数字（0 或 1）。
⚝ 例如：0b1010, 0B11110000。
1
#include <iostream>
2
3
int main() {
4
int flags = 0b11010110; // 使用二进制字面量表示标志位
5
std::cout << "Flags in decimal: " << flags << std::endl; // 输出 214
6
return 0;
7
}
这个特性使得表示与硬件寄存器、协议字段或位掩码相关的整数值变得更加直观。
数字分隔符（Digit Separators）：
⚝ C++14 还引入了单引号 ' 作为数字分隔符。
⚝ 可以在任何整数字面量（十进制、八进制、十六进制、二进制）或浮点数字面量的数字之间使用。
⚝ 它们纯粹用于提高可读性，不改变字面量的值。
1
#include <iostream>
2
#include <cstdint>
3
4
int main() {
5
long long big_number = 1'000'000'000LL; // 十进制分隔
6
int hex_value = 0xFF'EE'DD'CC; // 十六进制分隔
7
unsigned int binary_flags = 0b1101'0110'1001'1110; // 二进制分隔
8
int octal_value = 0123'456'701; // 八进制分隔
9
10
std::cout << "Big number: " << big_number << std::endl;
11
std::cout << "Hex value: " << std::hex << hex_value << std::dec << std::endl; // 需要 std::hex
12
std::cout << "Binary flags: " << binary_flags << std::endl;
13
std::cout << "Octal value: " << octal_value << std::endl;
14
15
return 0;
16
}
数字分隔符允许开发者按照喜欢的风格（如每三位、每四位或每八位）对数字进行分组，特别是对于很长或者表示特定结构的字面量（如 IP 地址的十六进制表示，或者位字段的二进制表示），极大地增强了代码的可读性和维护性。
这些 C++14 特性的价值：
⚝ 提高可读性： 使复杂的字面量更易于阅读和理解。
⚝ 减少错误： 清晰的字面量形式有助于避免手误或误读。
⚝ 代码意图清晰： 二进制字面量直接表达了值的二进制结构。
10.3 C++17: 结构化绑定与整数类型
摘要： 简要提及结构化绑定在处理包含整数的结构或数组时的应用。
结构化绑定（Structured Binding）是 C++17 中引入的一个非常方便的特性，它允许开发者将一个复合类型（如结构体 struct、类 class、数组 array 或对 pair、元组 tuple 等）的成员或元素解包（unpack）到一组独立的变量中。虽然结构化绑定本身不是对整数类型本身的改变，但它经常用于处理包含整数成员的复合类型，使得访问这些整数成员的代码更加简洁。
结构化绑定的基本用法：
对于一个结构体：
1
struct Point {
2
int x;
3
int y;
4
};
5
6
Point p = {10, 20};
7
8
// 使用结构化绑定解包
9
auto [px, py] = p;
10
11
// 现在可以使用 px 和 py 就像使用 p.x 和 p.y 一样
12
std::cout << "Point coordinates: " << px << ", " << py << std::endl;
在这个例子中，结构体 Point 包含两个整数成员 x 和 y。结构化绑定 auto [px, py] = p; 创建了两个新的变量 px 和 py，它们分别绑定到 p.x 和 p.y。这避免了需要写 p.x 和 p.y 的冗长语法，尤其是在需要访问多个成员时。
对于数组：
1
int coordinates[] = {100, 200};
2
3
// 使用结构化绑定解包数组元素
4
auto [cx, cy] = coordinates;
5
6
std::cout << "Array elements: " << cx << ", " << cy << std::endl;
这里，包含整数元素的数组 coordinates 被解包到 cx 和 cy 两个整数变量中。
与整数类型的关联：
结构化绑定本身不改变整数类型的行为或表示，但它简化了访问和处理存储在聚合或类类型中的整数数据的语法。它使得编写涉及从函数返回结构体或对、迭代包含整数的范围等场景的代码时，与整数数据的交互更加流畅和直观。
结构化绑定的优点：
⚝ 代码简洁： 减少了重复访问成员的语法。
⚝ 可读性增强： 变量名直接出现在绑定声明中，意图清晰。
⚝ 方便函数返回多个值： 函数可以返回一个结构体或元组，调用者可以使用结构化绑定轻松获取返回值。
10.4 C++20 及后续: 潜在的相关特性
摘要： 展望未来标准中可能出现的与整数类型相关的新特性或改进，以及现有特性对整数使用的影响。
C++ 标准委员会一直在不断演进和改进语言。虽然 C++20 及后续标准（如 C++23, C++26）没有对基本整数类型本身进行根本性的改变（例如，没有引入全新的基本整数类型），但引入了一些特性，这些特性可能会影响整数类型的编程实践、底层表示的探究或在特定场景下与整数的交互方式。
以下是一些 C++20 及后续标准中可能与整数类型相关的特性：
① std::endian (C++20)
▮▮▮▮这个特性提供了查询当前系统字节序（Endianness）的标准方法。字节序是指多字节数据（如 int, long long 等）在内存中的存储顺序（大端序 Big-Endian 或小端序 Little-Endian）。理解字节序对于处理跨平台二进制数据、网络通信或低级别内存操作中的整数至关重要。std::endian 的引入提供了一个可移植的方式来确定或处理字节序问题。
1
#include <iostream>
2
#include <bit> // C++20 引入
3
4
int main() {
5
if (std::endian::native == std::endian::little) {
6
std::cout << "System is little-endian." << std::endl;
7
} else if (std::endian::native == std::endian::big) {
8
std::cout << "System is big-endian." << std::endl;
9
} else {
10
std::cout << "System is mixed-endian or unknown." << std::endl;
11
}
12
return 0;
13
}
② std::bit_cast (C++20)
▮▮▮▮std::bit_cast 提供了一种安全且清晰的方式来对两个具有相同大小（且都是可平凡复制 TrivialyCopyable）的类型之间进行按位重解释。这在需要将整数的位模式解释为浮点数，或者反之，或者在不同整数类型之间进行位模式转换时非常有用，例如，实现快速的反平方根算法或处理某些特定的数据格式。它比 C 风格的强制类型转换或 reinterpret_cast 更安全，因为它有类型和大小的检查。
1
#include <iostream>
2
#include <bit> // C++20 引入
3
#include <cstdint> // C++11 引入
4
5
int main() {
6
uint32_t int_value = 0x40490FDB; // IEEE 754 单精度浮点数表示 PI/2 的位模式
7
float float_value = std::bit_cast<float>(int_value);
8
9
std::cout << "Integer bit pattern: 0x" << std::hex << int_value << std::dec << std::endl;
10
std::cout << "Reinterpreted as float: " << float_value << std::endl; // 输出接近 1.57
11
12
return 0;
13
}
尽管它主要用于位模式的重解释，但其源类型或目标类型经常是整数类型。
③ consteval 和增强的 constexpr (C++20 onwards)
▮▮▮▮C++20 引入的 consteval 说明符强制函数在编译时执行。对 constexpr 的持续增强也使得更多的代码（包括循环、条件、内存分配/释放等）可以在编译时执行。这意味着更多涉及整数的复杂计算和逻辑可以在编译时完成，提高了运行时性能，并允许将更多的工作推迟到编译阶段。这影响了如何使用整数常量和在编译时进行整数运算的最佳实践。
④ 对未定义行为的标准化或澄清
▮▮▮▮C++ 标准的持续演进也在不断地对现有规则进行澄清和完善，特别是一些涉及未定义行为（Undefined Behavior, UB）的场景。虽然这不直接引入新的整数类型，但它可能影响到某些边界情况下的整数运算（例如，有符号整数溢出、某些位移操作）的处理方式或开发者对其行为的理解。委员会可能会提供更多的工具或语言特性来帮助开发者避免这些未定义行为。
⑤ 模块（Modules）(C++20)
▮▮▮▮模块系统改变了代码的组织方式，但对整数类型本身没有直接影响。不过，它有助于更清晰地隔离和管理代码库中与整数类型相关的常量、类型别名或函数。
总的来说，C++ 在整数类型方面的演进主要集中在提高它们的可移植性（固定宽度整数）、可读性（二进制字面量、数字分隔符）以及提供更强大的底层控制和编译时能力。未来的标准可能会继续在这些方向上探索，并可能引入更多工具来帮助开发者安全、高效地使用整数类型。
Appendix A: 常用整数类型及其最小保证范围
Appendix A1: 引言：标准保证的意义
在 C++ 中，基本整数类型的大小（占据的内存字节数）和因此决定的数值范围并不是在所有平台上都完全固定的。C++ 标准委员会认识到不同的硬件架构可能有不同的字长（Word Size）和内存寻址能力，因此提供了一定程度的灵活性。然而，为了保证程序的可移植性（Portability），标准规定了每种基本整数类型必须能够表示的最小数值范围。
这意味着，一个符合标准的 C++ 编译器在特定平台上提供的 int 类型，其数值范围至少要达到标准规定的最小值，但可能更大。例如，标准要求 int 至少能表示 \([-32767, +32767]\) 的范围，这对应于一个至少 16 位的有符号整数。在大多数现代系统上，int 通常是 32 位或 64 位，其范围远超这个最小值。
理解这些最小保证范围对于编写可移植的代码至关重要。如果你的程序依赖于某个整数类型具有大于标准保证的范围（例如，假设 int 总是 32 位），那么在只有 16 位 int 的平台上编译时，可能会遇到意想不到的溢出（Overflow）问题。
本附录将列出 C++ 标准（通常参照最新的标准，但核心保证自 C++98 以来基本稳定）对各种常用整数类型所规定的最小表示范围。这些范围通常在标准库头文件 <climits> (对应 C 语言的 limits.h) 中以宏（Macro）的形式定义。
Appendix A2: 基本整数类型的最小范围保证
下表列出了 C++ 标准对各种基本整数类型所保证的最小位宽（Bit Width）和对应的数值范围。这里的“最小位宽”是指类型必须能够支持的最小范围所需的位数，而非其实际占用的位数。实际位数可以通过 sizeof 运算符和 CHAR_BIT（在 <climits> 中，表示一个字节的位数，通常为 8）来确定。
类型大小的顺序保证：
C++ 标准对整数类型的大小有以下最小保证顺序：
\[ \text{sizeof(char)} \le \text{sizeof(short)} \le \text{sizeof(int)} \le \text{sizeof(long)} \le \text{sizeof(long long)} \]
并且，short 至少是 16 位，int 至少是 16 位，long 至少是 32 位，long long 至少是 64 位。
Appendix A2.1: char 系列
⚝ signed char (有符号字符)
▮▮▮▮⚝ 最小位宽：8 位
▮▮▮▮⚝ 最小范围：\([-127, +127]\)。在 <climits> 中，由 SCHAR_MIN 和 SCHAR_MAX 定义。需要注意的是，如果使用二进制补码（Two's Complement）表示负数，8 位有符号数的实际范围是 \([-128, +127]\)。标准保证至少 \([-127, +127]\)，但大多数实现会达到 \([-128, +127]\)。
⚝ unsigned char (无符号字符)
▮▮▮▮⚝ 最小位宽：8 位
▮▮▮▮⚝ 最小范围：\([0, 255]\)。在 <climits> 中，由 UCHAR_MAX 定义（0 是隐式的）。
⚝ char (字符)
▮▮▮▮⚝ 最小位宽：8 位
▮▮▮▮⚝ 范围：与 signed char 或 unsigned char 之一相同，取决于具体实现（平台）。在 <climits> 中，由 CHAR_MIN 和 CHAR_MAX 定义。其符号性由实现定义（Implementation-defined），但其范围一定能容纳目标字符集（Target Character Set）的基本字符。
Appendix A2.2: short 系列
⚝ short int 或 short (短整数)
▮▮▮▮⚝ 最小位宽：16 位
▮▮▮▮⚝ 最小范围：\([-32767, +32767]\)。在 <climits> 中，由 SHRT_MIN 和 SHRT_MAX 定义。与 signed char 类似，如果使用二进制补码，16 位有符号数的实际范围是 \([-32768, +32767]\)，标准保证至少 \([-32767, +32767]\)。
⚝ unsigned short int 或 unsigned short (无符号短整数)
▮▮▮▮⚝ 最小位宽：16 位
▮▮▮▮⚝ 最小范围：\([0, 65535]\)。在 <climits> 中，由 USHRT_MAX 定义。
Appendix A2.3: int 系列
⚝ int (整数)
▮▮▮▮⚝ 最小位宽：16 位 (但通常在现代系统上是 32 位或 64 位)
▮▮▮▮⚝ 最小范围：\([-32767, +32767]\)。在 <climits> 中，由 INT_MIN 和 INT_MAX 定义。这是一个非常宽松的保证，int 的实际范围通常远大于此。
⚝ unsigned int (无符号整数)
▮▮▮▮⚝ 最小位宽：16 位 (但通常在现代系统上是 32 位或 64 位)
▮▮▮▮⚝ 最小范围：\([0, 65535]\)。在 <climits> 中，由 UINT_MAX 定义。与 int 类似，实际范围通常更大。
Appendix A2.4: long 系列
⚝ long int 或 long (长整数)
▮▮▮▮⚝ 最小位宽：32 位
▮▮▮▮⚝ 最小范围：\([-2147483647, +2147483647]\)。在 <climits> 中，由 LONG_MIN 和 LONG_MAX 定义。如果使用二进制补码，32 位有符号数的实际范围是 \([-2147483648, +2147483647]\)，标准保证至少 \([-2147483647, +2147483647]\)。
⚝ unsigned long int 或 unsigned long (无符号长整数)
▮▮▮▮⚝ 最小位宽：32 位
▮▮▮▮⚝ 最小范围：\([0, 4294967295]\)。在 <climits> 中，由 ULONG_MAX 定义。
Appendix A2.5: long long 系列 (C++11 起)
⚝ long long int 或 long long (长长整数)
▮▮▮▮⚝ 最小位宽：64 位
▮▮▮▮⚝ 最小范围：\([-9223372036854775807, +9223372036854775807]\)。在 <climits> 中，由 LLONG_MIN 和 LLONG_MAX 定义。如果使用二进制补码，64 位有符号数的实际范围是 \([-9223372036854775808, +9223372036854775807]\)，标准保证至少 \([-9223372036854775807, +9223372036854775807]\)。
⚝ unsigned long long int 或 unsigned long long (无符号长长整数)
▮▮▮▮⚝ 最小位宽：64 位
▮▮▮▮⚝ 最小范围：\([0, 18446744073709551615]\)。在 <climits> 中，由 ULLONG_MAX 定义。
Appendix A3: 使用 <climits> 或 <limits> 获取实际范围
虽然标准只保证最小范围，但在实际编程中，我们通常需要知道当前平台下某个类型的确切范围。C++ 提供了两种主要方式来获取这些信息：
① <climits> 头文件：
▮▮▮▮这是 C 语言 limits.h 的 C++ 版本，通过宏提供各种整数类型的范围信息。例如：
1
#include <climits>
2
#include <iostream>
3
4
int main() {
5
std::cout << "int 的最小范围: " << INT_MIN << " 到 " << INT_MAX << std::endl;
6
std::cout << "unsigned int 的最大值: " << UINT_MAX << std::endl;
7
std::cout << "long long 的最小范围: " << LLONG_MIN << " 到 " << LLONG_MAX << std::endl;
8
std::cout << "一个字节的位数: " << CHAR_BIT << std::endl;
9
return 0;
10
}
▮▮▮▮这些宏定义的是当前编译环境下对应类型的实际范围。
② <limits> 头文件：
▮▮▮▮这是 C++ 风格的获取类型属性的方式，通过 std::numeric_limits 类模板提供更全面的信息，不仅限于整数类型。它提供了静态成员函数来获取类型的最小/最大值、位数、是否有符号等信息。
1
#include <limits>
2
#include <iostream>
3
4
int main() {
5
std::cout << "int 的最小范围: " << std::numeric_limits<int>::min()
6
<< " 到 " << std::numeric_limits<int>::max() << std::endl;
7
std::cout << "unsigned int 的最大值: " << std::numeric_limits<unsigned int>::max() << std::endl;
8
std::cout << "long long 的最小范围: " << std::numeric_limits<long long>::min()
9
<< " 到 " << std::numeric_limits<long long>::max() << std::endl;
10
std::cout << "int 的位数 (不包括符号位): " << std::numeric_limits<int>::digits << std::endl; // 例如，31 for 32-bit signed int
11
std::cout << "unsigned int 的位数: " << std::numeric_limits<unsigned int>::digits << std::endl; // 例如，32 for 32-bit unsigned int
12
std::cout << "int 是否有符号: " << std::numeric_limits<int>::is_signed << std::endl;
13
return 0;
14
}
▮▮▮▮使用 std::numeric_limits 通常被认为是更现代、更具 C++ 特色的方式，因为它适用于所有基本类型，而不仅仅是整数。digits 成员表示该类型值表示部分的位数，对于有符号类型通常是总位数减一（减去符号位）。
Appendix A4: 总结与应用
本附录列出的最小保证范围是 C++ 标准为了确保基本可移植性而设定的底线。在编写对性能或内存有严格要求，或者需要与特定硬件交互的代码时，了解实际平台上的整数类型大小和范围（通过 <climits> 或 <limits>）非常重要。然而，对于大多数通用编程任务，如果只需要存储不超出标准最小范围的数值，依赖标准保证的范围可以提高代码的可移植性。对于需要精确控制位宽的场景，应优先考虑使用 <cstdint> 中定义的固定宽度整数类型（如 int32_t, uint64_t 等），它们在标准允许的情况下保证了确切的位宽。
Appendix B: 推荐的头文件与标准库工具
本附录旨在总结在使用 C++ 整数类型时，可以充分利用的标准库头文件和其中提供的强大工具。这些工具不仅能够帮助我们编写更加安全、可移植的代码，还能让我们获取关于整数类型的重要属性信息。我们将重点介绍 <cstdint> 和 <limits>（以及相关的 <climits>) 头文件。
Appendix B1: <cstdint>：固定宽度整数类型
<cstdint> 是 C++11 标准引入的头文件，它提供了一组定义了精确宽度、最小宽度等的整数类型别名。这些类型别名有助于编写需要特定位宽整数的代码，例如处理二进制数据、网络协议或者需要确保跨平台行为一致性的场景。使用这些类型可以提高代码的可移植性和可读性。
<cstdint> 中定义的类型主要包括：
① 确切宽度整数类型（Exact-width Integer Types）
▮▮▮▮这些类型保证具有指定的位宽（不包括符号位），并且没有填充位（padding bits）。如果平台不支持某个确切宽度的整数类型，则该类型不会被定义。
▮▮▮▮例如：
▮▮▮▮ⓐ int8_t：8 位有符号整数。
▮▮▮▮ⓑ int16_t：16 位有符号整数。
▮▮▮▮ⓒ int32_t：32 位有符号整数。
▮▮▮▮ⓓ int64_t：64 位有符号整数。
▮▮▮▮ⓔ uint8_t：8 位无符号整数。
▮▮▮▮ⓕ uint16_t：16 位无符号整数。
▮▮▮▮ⓖ uint32_t：32 位无符号整数。
▮▮▮▮ⓗ uint64_t：64 位无符号整数。
② 最小宽度整数类型（Minimum-width Integer Types）
▮▮▮▮这些类型保证至少具有指定的位宽。它们是平台提供的满足最小位宽要求的“最合适”（但不一定是“最快”）的类型。
▮▮▮▮例如：
▮▮▮▮ⓐ int_least8_t：至少 8 位的有符号整数。
▮▮▮▮ⓑ int_least16_t：至少 16 位的有符号整数。
▮▮▮▮ⓒ int_least32_t：至少 32 位的有符号整数。
▮▮▮▮ⓓ int_least64_t：至少 64 位的有符号整数。
▮▮▮▮ⓔ uint_least8_t：至少 8 位的无符号整数。
▮▮▮▮ⓕ uint_least16_t：至少 16 位的无符号整数。
▮▮▮▮ⓖ uint_least32_t：至少 32 位的无符号整数。
▮▮▮▮ⓗ uint_least64_t：至少 64 位的无符号整数。
③ 最快最小宽度整数类型（Fastest minimum-width types）
▮▮▮▮这些类型保证至少具有指定的位宽，并且是平台在满足此要求的所有类型中处理速度最快的。
▮▮▮▮例如：
▮▮▮▮ⓐ int_fast8_t：至少 8 位的最快有符号整数。
▮▮▮▮ⓑ int_fast16_t：至少 16 位的最快有符号整数。
▮▮▮▮ⓒ int_fast32_t：至少 32 位的最快有符号整数。
▮▮▮▮ⓓ int_fast64_t：至少 64 位的最快有符号整数。
▮▮▮▮ⓔ uint_fast8_t：至少 8 位的最快无符号整数。
▮▮▮▮ⓕ uint_fast16_t：至少 16 位的最快无符号整数。
▮▮▮▮ⓖ uint_fast32_t：至少 32 位的最快无符号整数。
▮▮▮▮ⓗ uint_fast64_t：至少 64 位的最快无符号整数。
④ 指针宽度整数类型（Pointer-width Types）
▮▮▮▮这些类型足以存储任何数据指针的值。它们通常用于指针算术或在需要将指针转换为整数进行存储或传递时。
▮▮▮▮例如：
▮▮▮▮ⓐ intptr_t：足以存储 void* 的有符号整数类型。
▮▮▮▮ⓑ uintptr_t：足以存储 void* 的无符号整数类型。
⑤ 最大宽度整数类型（Greatest-width Types）
▮▮▮▮这些类型能够存储任何其他整数类型（包括基本整数类型和上面提到的固定宽度类型）的值。
▮▮▮▮例如：
▮▮▮▮ⓐ intmax_t：能够存储任何有符号整数类型值的有符号整数类型。
▮▮▮▮ⓑ uintmax_t：能够存储任何无符号整数类型值的无符号整数类型。
⑥ 其他重要类型
▮▮▮▮除了上述类型别名外，<cstdint> 通常还会通过包含 <cstddef> 提供 size_t 和 ptrdiff_t。
▮▮▮▮ⓐ size_t：无符号整数类型，用于表示对象的大小或数量，通常是 sizeof 运算符的结果类型。
▮▮▮▮ⓑ ptrdiff_t：有符号整数类型，用于表示两个指针之间的差值。
使用示例：
1
#include <cstdint>
2
#include <iostream>
3
4
int main() {
5
// 使用确切宽度整数类型
6
int32_t a = 100000; // 保证是 32 位
7
uint64_t b = 0xFFFFFFFFFFFFFFFFULL; // 保证是 64 位无符号
8
9
// 使用最小宽度整数类型
10
int_least16_t c = -500; // 保证至少 16 位
11
12
// 使用指针宽度类型
13
int* ptr = nullptr;
14
uintptr_t ptr_value = reinterpret_cast<uintptr_t>(ptr); // 将指针值转换为整数
15
16
// 使用 size_t
17
size_t array_size = 100;
18
19
std::cout << "sizeof(int32_t): " << sizeof(int32_t) << " 字节(bytes)" << std::endl;
20
std::cout << "sizeof(uint64_t): " << sizeof(uint64_t) << " 字节(bytes)" << std::endl;
21
std::cout << "sizeof(size_t): " << sizeof(size_t) << " 字节(bytes)" << std::endl;
22
23
return 0;
24
}
Appendix B2: <limits> 和 <climits>：获取整数类型属性信息
这两个头文件提供了关于基本数据类型（包括整数类型）属性的信息，例如最大值、最小值、位数等。
① <limits> 与 std::numeric_limits
▮▮▮▮<limits> 头文件提供了 std::numeric_limits 类模板。这是一个模板类，通过模板参数指定具体的数据类型，然后可以通过其静态成员函数或静态成员常量获取该类型的各种属性。这是 C++ 风格的方式，推荐在 C++ 代码中使用。
▮▮▮▮std::numeric_limits<T> 为整数类型 T 提供了以下一些重要的静态成员：
▮▮▮▮ⓐ std::numeric_limits<T>::is_specialized: 布尔值，如果该类型有专门的模板实现则为 true。基本类型都有专门实现。
▮▮▮▮ⓑ std::numeric_limits<T>::min(): 返回该类型能够表示的最小值。对于有符号整数，这是最大的负数（通常是 \(-(2^{N-1})\)）。对于无符号整数，这是 0。
▮▮▮▮ⓒ std::numeric_limits<T>::max(): 返回该类型能够表示的最大值。对于有符号整数，这是 \(2^{N-1}-1\)。对于无符号整数，这是 \(2^N-1\)。
▮▮▮▮ⓓ std::numeric_limits<T>::lowest(): 返回该类型能够表示的最小有限值。对于整数类型，这与 min() 相同。
▮▮▮▮ⓔ std::numeric_limits<T>::digits: 返回该类型的“有效位数”（不包括符号位）。对于整数类型，这是表示数值的二进制位数。
▮▮▮▮ⓕ std::numeric_limits<T>::digits10: 返回在该类型整个范围内，可以保证不丢失精度的十进制位数。
▮▮▮▮ⓖ std::numeric_limits<T>::is_signed: 布尔值，如果类型是有符号的则为 true。
▮▮▮▮ⓗ std::numeric_limits<T>::is_unsigned: 布尔值，如果类型是无符号的则为 true。
▮▮▮▮ⓘ std::numeric_limits<T>::is_integer: 布尔值，如果类型是整数类型则为 true。
▮▮▮▮ⓙ std::numeric_limits<T>::is_bounded: 布尔值，如果数值范围是有限的则为 true（整数类型是有限的）。
▮▮▮▮使用示例：
1
#include <limits>
2
#include <iostream>
3
#include <cstdint> // 也适用于 <cstdint> 中的类型
4
5
int main() {
6
std::cout << "--- int 类型属性 ---" << std::endl;
7
std::cout << "最小值 (min): " << std::numeric_limits<int>::min() << std::endl;
8
std::cout << "最大值 (max): " << std::numeric_limits<int>::max() << std::endl;
9
std::cout << "二进制位数 (digits): " << std::numeric_limits<int>::digits << std::endl;
10
std::cout << "十进制位数 (digits10): " << std::numeric_limits<int>::digits10 << std::endl;
11
std::cout << "是否有符号 (is_signed): " << std::boolalpha << std::numeric_limits<int>::is_signed << std::endl;
12
std::cout << "是否无符号 (is_unsigned): " << std::boolalpha << std::numeric_limits<int>::is_unsigned << std::endl;
13
std::cout << "是否是整数 (is_integer): " << std::boolalpha << std::numeric_limits<int>::is_integer << std::endl;
14
15
std::cout << "\n--- uint32_t 类型属性 ---" << std::endl;
16
std::cout << "最小值 (min): " << std::numeric_limits<uint32_t>::min() << std::endl;
17
std::cout << "最大值 (max): " << std::numeric_limits<uint32_t>::max() << std::endl;
18
std::cout << "二进制位数 (digits): " << std::numeric_limits<uint32_t>::digits << std::endl;
19
std::cout << "十进制位数 (digits10): " << std::numeric_limits<uint32_t>::digits10 << std::endl;
20
std::cout << "是否有符号 (is_signed): " << std::boolalpha << std::numeric_limits<uint32_t>::is_signed << std::endl;
21
std::cout << "是否无符号 (is_unsigned): " << std::boolalpha << std::numeric_limits<uint32_t>::is_unsigned << std::endl;
22
23
return 0;
24
}
② <climits> (或 <limits.h>)
▮▮▮▮<climits> 头文件继承自 C 语言的 <limits.h>，提供了关于 C++ 基本整数类型的各种属性的宏定义。这是一种 C 风格的方式，在 C++ 中通常更推荐使用 <limits>。
▮▮▮▮一些常用的宏定义包括：
▮▮▮▮ⓐ CHAR_BIT: char 中的位数。
▮▮▮▮ⓑ SCHAR_MIN, SCHAR_MAX: signed char 的最小值和最大值。
▮▮▮▮ⓒ UCHAR_MAX: unsigned char 的最大值。
▮▮▮▮ⓓ SHRT_MIN, SHRT_MAX: short int 的最小值和最大值。
▮▮▮▮ⓔ USHRT_MAX: unsigned short int 的最大值。
▮▮▮▮ⓕ INT_MIN, INT_MAX: int 的最小值和最大值。
▮▮▮▮ⓖ UINT_MAX: unsigned int 的最大值。
▮▮▮▮ⓗ LONG_MIN, LONG_MAX: long int 的最小值和最大值。
▮▮▮▮ⓘ ULONG_MAX: unsigned long int 的最大值。
▮▮▮▮ⓙ LLONG_MIN, LLONG_MAX: long long int 的最小值和最大值 (C++11/C99)。
▮▮▮▮ⓚ ULLONG_MAX: unsigned long long int 的最大值 (C++11/C99)。
▮▮▮▮使用示例：
1
#include <climits>
2
#include <iostream>
3
4
int main() {
5
std::cout << "--- <climits> 提供的宏 ---" << std::endl;
6
std::cout << "int 最小值 (INT_MIN): " << INT_MIN << std::endl;
7
std::cout << "int 最大值 (INT_MAX): " << INT_MAX << std::endl;
8
std::cout << "unsigned int 最大值 (UINT_MAX): " << UINT_MAX << std::endl;
9
std::cout << "char 位数 (CHAR_BIT): " << CHAR_BIT << std::endl;
10
11
return 0;
12
}
请注意，<climits> 提供的宏对应的是基本整数类型（如 int, long 等），而不是 <cstdint> 中定义的固定宽度类型。对于固定宽度类型，应该使用 std::numeric_limits。
Appendix B3: 其他相关工具
除了上述两个核心头文件外，C++ 标准库还提供了一些与整数操作相关的函数，例如：
⚝ 绝对值函数（Absolute Value Functions）:
▮▮▮▮<cmath> 或 <cstdlib> 头文件提供了获取整数绝对值的函数。
▮▮▮▮例如：
1
#include <cstdlib> // 或 <cmath>
2
3
int main() {
4
int i = -10;
5
long l = -1000L;
6
long long ll = -100000LL;
7
8
int abs_i = std::abs(i); // C++11+ 推荐使用 std::abs
9
// 或者使用 C 风格函数：
10
// int abs_i_c = abs(i);
11
// long abs_l_c = labs(l);
12
// long long abs_ll_c = llabs(ll);
13
14
return 0;
15
}