类型转换

写过几行 C++ 代码之后，你一定会碰到这样的情况：一个 int 需要变成 double，一个 double 需要截断成 int，或者一个有符号数和一个无符号数在做比较。类型转换在真实的程序里几乎无处不在——而你如果不理解它的规则，编译器就会在背后悄悄替你做决定，然后你在某个深夜收获一个完全看不懂的 bug。

这一章我们要把类型转换的规则彻底搞清楚：编译器什么时候自动帮你转，什么时候需要你明确指定，以及那些经典的精度陷阱怎么避。

⚠️ 踩坑预警：类型转换相关的 bug 有一个特别讨厌的特性——在最默认的情况下，它往往不会导致编译错误，也不会让程序崩溃，而是悄无声息地给出一个错误的计算结果。所以笔者建议，咱们就把警告设置为错误。笔者的CFbox项目就是这样约束流水线的。防止一些奇怪的corner case炸出来我们不希望的结果。

隐式转换——编译器背后的暗箱操作

所谓隐式转换，就是编译器认为"这里类型不匹配，但我知道怎么处理"，于是自动帮你做了转换，不需要你写任何额外的代码。这听起来很贴心，但如果你不知道它的规则，那它就像一个自作主张的助手，好心办坏事。

整数提升与算术转换

C++ 的隐式转换有几条核心规则。第一条是整数提升：比 int 更小的整数类型（bool、char、short 等）在参与运算时会自动提升为 int。比如两个 char 相加，结果类型是 int 而不是 char——因为很多 CPU 上 int 是原生运算宽度，效率最高。

第二条是算术转换：当两个不同类型的值一起做运算时，编译器会"往大的类型靠"。int 和 double 相加，int 先被转成 double，结果是 double。但反过来，把 double 赋值给 int 就会截断小数部分——不是四舍五入，是直接砍掉。

来看一个综合示例，把这几种隐式转换都过一遍：

#include <iostream>

int main()
{
    // 赋值转换：double -> int，小数部分直接截断
    double pi = 3.14159;
    int truncated = pi;
    std::cout << "3.14159 -> int: " << truncated << std::endl;  // 3

    // 算术转换：int + double -> double
    int i = 5;
    double d = 2.5;
    auto result = i + d; // 不知道啥类型，鼠标hover到auto这个单词上，IDE会提示你的
    std::cout << "5 + 2.5 = " << result << " (double)" << std::endl;  // 7.5

    // 布尔转换：零 -> false，非零 -> true
    bool b1 = 42;   // true，输出为 1
    bool b2 = -3;   // true
    bool b3 = 0;    // false，输出为 0
    std::cout << "42->" << b1 << ", -3->" << b2 << ", 0->" << b3
              << std::endl;  // 1, 1, 0
    return 0;
}

隐式转换的经典翻车现场

了解规则是一回事，真正被坑到是另一回事。我们来看两个在实际项目中高频出现的典型案例。

有符号与无符号的碰撞

int a = -1;
unsigned int b = a;  // 有符号转无符号
// a = -1, b = 4294967295

-1 的二进制表示是全 1（补码），把它解释为无符号整数就成了 4294967295（即 2^32 - 1）。编译器一个字都不会提醒你。更恐怖的是，如果你拿有符号数和无符号数做比较，编译器会把有符号数隐式转换成无符号数来比较，结果会让你非常困惑。

⚠️ 踩坑预警：有符号与无符号数的比较是一个特别高发的 bug 来源。比如你用 int i 去和 vector.size()（返回 size_t，是无符号类型）比较，如果 i 是负数，它会被转换成一个巨大的无符号数，比较结果完全反转。很多编译器在开启 -Wall -Wextra 后会对这种情况给出警告，所以一定要打开这些警告选项。

溢出——你以为的"小数字"不一定是小数字

short s = 32767;   // short 的最大值（假设 16 位）
s = s + 1;         // 溢出！输出 -32768

short 能表示的最大正数是 32767，再加 1 就溢出了。虽然计算时 s 被提升成 int、中间结果 32768 在 int 范围内，但赋值回 short 时发生截断，结果回绕到 -32768。

C 风格转型——能用但别用

在 C 语言里，显式类型转换有两种写法：(int)d 和 int(d)。它们在 C++ 里依然合法，但是一种"暴力"手段——编译器几乎不会拒绝你，不管这个转换是否合理。C++ 提供了四个具名的转型运算符，各自有明确的用途，我们接下来看日常用得最多的那个。

static_cast——日常转型的主力工具

static_cast 是我们用得最多的转型运算符，语法是 static_cast<目标类型>(表达式)。它在编译时进行检查，能做大多数"合理"的转换，同时拒绝明显不合理的操作。

#include <iostream>

int main()
{
    int i = 42;
    double d = static_cast<double>(i);       // int -> double，输出 42
    double pi = 3.14159;
    int truncated = static_cast<int>(pi);    // double -> int，输出 3

    std::cout << d << " " << truncated << std::endl;
    return 0;
}

你可能会问：这和直接赋值有什么区别？区别在于意图明确。static_cast 在代码里大声告诉读代码的人"这里确实需要类型转换，我清楚自己在干什么"，而隐式转换是悄悄发生的。另外一个重要的区别是，static_cast 会做编译期检查——如果你试图把一个 int* 转成 double*，static_cast 会直接报错拒绝，因为这两种指针类型之间不存在合理的转换路径。

reinterpret_cast——重新解释底层的位模式

static_cast 做不了的事情里，有一大类是"把一段内存当作另一种类型来用"。比如你拿到一个 void* 指针，需要把它转回 int* 才能解引用；或者你需要把一个 float 的底层位模式当作 uint32_t 来查看。这些操作超出了类型系统的安全保证范围，编译器没法帮你检查合理性——这时候就需要 reinterpret_cast。

#include <iostream>
#include <cstdint>

int main()
{
    // 场景一：void* 和类型指针之间的转换
    int value = 100;
    void* pv = &value;
    int* pi = reinterpret_cast<int*>(pv);
    std::cout << *pi << std::endl;  // 100

    // 场景二：查看浮点数的底层位模式
    float f = 1.0f;
    uint32_t bits = reinterpret_cast<uint32_t&>(f);
    // 1.0f 的 IEEE 754 表示：0x3f800000
    std::cout << std::hex << bits << std::endl;

    return 0;
}

reinterpret_cast 的名字就说明了一切——"重新解释"。它不改变底层的二进制数据，只是告诉编译器"请把这段内存当作另一种类型来看待"。正因为如此，它也是最危险的转型运算符，用错了直接就是未定义行为。

⚠️ 踩坑预警：reinterpret_cast 的很多用法都是未定义行为或实现定义行为。比如把 int* 转成 double* 再解引用，由于对齐要求和大小不同，结果完全不可预测。它真正安全的用例其实很少：void* 和原始指针类型之间的互转、基于 unsigned char 的底层字节观察，以及一些序列化和硬件寄存器访问的场景。在嵌入式开发中我们会更频繁地遇到它，但在主机端的应用代码里基本用不上。一个简单的经验法则：日常开发中 95% 的显式转型用 static_cast 就够了，如果你发现自己想用 reinterpret_cast，先停下来想想是不是设计上出了问题。

const_cast 与 dynamic_cast（简介）

const_cast 用来移除或添加 const 限定——如果原始对象本身就是 const 的，强行移除 const 去写入是未定义行为。dynamic_cast 用于继承体系中的安全向下转型，会在运行时检查对象的真实类型，等我们学完面向对象之后再详细讨论。

数值精度——那些让你怀疑人生的时刻

类型转换引出的另一个大话题是数值精度。这里我们来看三个最经典的场景。

整数除法的陷阱

int a = 5, b = 2;
double result = a / b;           // 整数除法！结果是 2，不是 2.5
double correct = static_cast<double>(a) / b;  // 正确：5.0 / 2 = 2.5

a / b 两个操作数都是 int，执行整数除法，结果也是 int。虽然左边的变量是 double，但那只是把结果 2 转成了 2.0 而已。赋值发生在运算之后——想拿到浮点结果，必须在除法之前就把至少一个操作数转成浮点类型。

⚠️ 踩坑预警：整数除法截断是新手最常犯的错误之一，特别是在计算平均值、百分比的时候。记住：只要除号两边都是整数，结果一定是整数。想要浮点结果，至少把分子或分母中的一个转成 double。

浮点数比较的不可靠性

#include <iostream>
#include <cmath>

int main()
{
    double a = 0.1 + 0.2;
    double b = 0.3;

    // 直接比较：false！因为 0.1+0.2 实际存储为 0.30000000000000004
    std::cout << std::boolalpha << (a == b) << std::endl;  // false

    // 正确做法：判断差值是否足够小
    double epsilon = 1e-9;
    bool approx_equal = std::abs(a - b) < epsilon;
    std::cout << approx_equal << std::endl;  // true
    return 0;
}

0.1 + 0.2 不等于 0.3——因为 0.1 和 0.2 在二进制浮点数中无法精确表示，double 只能近似存储。正确做法是判断两个浮点数的差值是否小于一个足够小的阈值（epsilon）。

整数溢出——超出范围的后果

#include <climits>

int max_int = INT_MAX;     // 2147483647
int overflow = max_int + 1;  // 未定义行为！通常是 -2147483648

unsigned char uc = 255;
uc = uc + 1;               // 明确定义的回绕，变成 0

有符号整数溢出在 C++ 中是未定义行为——编译器可以对这种代码做任何事，虽然大多数实现会回绕到负数，但不能依赖这个行为。无符号整数的溢出则是明确定义的回绕行为，在嵌入式开发中有时会被有意使用（比如环形缓冲区），但必须是有意识的。

综合示例——conversion.cpp

现在我们把前面的知识点整合到一个完整的程序里，涵盖了隐式转换、static_cast、整数除法、浮点比较以及溢出。建议你先自己读一遍代码预测每行的输出，然后再看运行结果。

// conversion.cpp —— 类型转换综合演示
// Platform: host
// Standard: C++11

#include <iostream>
#include <cmath>
#include <climits>

int main()
{
    // 1. 隐式转换：double -> int
    double price = 9.99;
    int rounded = price;
    std::cout << "[隐式转换] 9.99 -> int: " << rounded << std::endl;

    // 2. static_cast：显式转换
    int count = 7;
    double avg = static_cast<double>(count) / 2;
    std::cout << "[static_cast] 7 / 2 = " << avg << std::endl;

    // 3. 整数除法陷阱
    int wrong = count / 2;
    std::cout << "[整数除法] 7 / 2 = " << wrong << std::endl;

    // 4. 有符号与无符号
    int neg = -1;
    unsigned int pos = static_cast<unsigned int>(neg);
    std::cout << "[有符号转无符号] -1 -> " << pos << std::endl;

    // 5. 浮点精度
    double x = 0.1 + 0.2;
    double y = 0.3;
    std::cout << "[浮点比较] (0.1+0.2) == 0.3: "
              << (x == y ? "true" : "false") << std::endl;

    // 6. 安全的浮点比较
    double epsilon = 1e-9;
    bool safe_eq = std::abs(x - y) < epsilon;
    std::cout << "[安全比较] approx equal: "
              << (safe_eq ? "true" : "false") << std::endl;

    // 7. 溢出
    int big = INT_MAX;
    std::cout << "[溢出] INT_MAX = " << big
              << ", +1 = " << big + 1 << std::endl;

    return 0;
}

编译运行：

g++ -Wall -Wextra -o conversion conversion.cpp
./conversion

[隐式转换] 9.99 -> int: 9
[static_cast] 7 / 2 = 3.5
[整数除法] 7 / 2 = 3
[有符号转无符号] -1 -> 4294967295
[浮点比较] (0.1+0.2) == 0.3: false
[安全比较] approx equal: true
[溢出] INT_MAX = 2147483647, +1 = -2147483648

逐行看下来，每一行输出都对应了前面讲过的某个规则。特别注意第 3 行和第 2 行的对比——同样是 7 / 2，有没有 static_cast<double> 结果完全不同。

动手试试

理论讲完了，接下来该你上场了。下面的练习层层递进，建议每道都动手写、动手编译、动手运行。

练习一：预测输出

不编译运行，先在纸上写下下面这段代码的输出结果，然后再用编译器验证：

#include <iostream>

int main()
{
    int a = 10;
    int b = 3;
    double c = a / b;
    double d = static_cast<double>(a) / b;

    std::cout << c << std::endl;
    std::cout << d << std::endl;

    unsigned int x = 10;
    int y = -1;
    std::cout << (x > y ? "x > y" : "x <= y") << std::endl;

    return 0;
}

第三行的实际输出是 x <= y——没错，直觉上 10 > -1 应该成立，但在混合比较有符号和无符号数时，-1 被隐式转换为无符号数（变成了 4294967295），所以比较的实际是 10 > 4294967295，结果自然是 false。如果你预测对了 x <= y，恭喜你已经理解了这个陷阱；如果预测成了 x > y，回头看"有符号与无符号的碰撞"那一节。

练习二：修复温度转换器

下面这段代码意图是摄氏转华氏，但结果有时不对。找出问题并修复它：

#include <iostream>

int main()
{
    int celsius = 25;
    // 公式：F = C * 9 / 5 + 32
    int fahrenheit = celsius * 9 / 5 + 32;
    std::cout << celsius << " C = " << fahrenheit << " F" << std::endl;
    return 0;
}

提示：试试把 celsius 改成 26，看看 26 * 9 / 5 得到的是 46.8 还是 46。

练习三：写一个安全的温度转换器

写一个完整的温度转换程序，从用户输入读取摄氏温度（支持小数），正确地转换成华氏温度并输出。要求使用正确的类型和 static_cast，输出保留一位小数。预期效果：

请输入摄氏温度: 36.5
36.5 C = 97.7 F

小结

这一章我们过了一遍 C++ 的类型转换机制。隐式转换在编译器幕后默默运作，涵盖整数提升、算术转换、赋值转换和布尔转换——不了解规则时它是隐形的 bug 来源。static_cast 是日常转型的主力，比 C 风格转型更安全、意图更明确。数值精度方面，整数除法截断、浮点数不可直接比较、整数溢出，每一个都是高频出现的陷阱。

记住几条核心原则：整数除法两边都是整数时结果一定是整数；浮点数永远不要用 == 比较，用差值和 epsilon 判断近似相等；有符号和无符号混合运算时要格外小心，开启编译器警告。下一章我们学习 const 的基础用法——如何让编译器帮我们守住"不该变的值"这条底线。