C++类型转换

一、C++类型转换的核心分类

C的类型转换分为隐式转换（编译器自动完成）和显式转换（手动指定），其中显式转换又包含C风格强制转换和C新增的安全转换运算符（推荐）。

转换类型	特点	适用场景	风险等级
隐式转换	编译器自动完成，无需手动干预	低风险类型兼容转换（如int→float）	低
C风格强制转换	(目标类型)源数据，简单粗暴	快速临时转换（不推荐生产环境）	高
static_cast	C++安全转换，编译期检查类型兼容性	基本类型/相关类指针转换	中
reinterpret_cast	二进制层面强制重解释，不做类型检查	指针/整数互转、不相关类型指针转换	极高
const_cast	仅用于移除/添加const属性	修改const变量（谨慎使用）	中
dynamic_cast	运行时类型检查，仅用于多态类	多态类的向下转型	低

二、具体转换方式详解（附示例）

1. 隐式转换（自动转换）

编译器在类型兼容时自动完成，优先发生在赋值、函数传参、算术运算场景。

#include <iostream>
using namespace std;

int main() {
    // 1. 数值类型兼容转换（低精度→高精度）
    int a = 10;
    double b = a; // int→double 隐式转换，b=10.0
    cout << b << endl;

    // 2. 算术运算中的转换（不同类型统一为高精度）
    int c = 5;
    double d = 3.14;
    double e = c + d; // c先隐式转double，再运算，e=8.14

    // 3. 指针隐式转换（void*兼容）
    int* p = &a;
    void* vp = p; // int*→void* 隐式转换（反向不行）

    return 0;
}

注意：隐式转换可能导致精度丢失（如double→int会截断小数），编译器可能报警告。

2. C风格强制转换（不推荐）

语法简单但无类型检查，容易引发未定义行为，仅临时调试使用。

int main() {
    // 1. 基本类型转换（可能丢失精度）
    double f = 3.99;
    int g = (int)f; // 强制转换，g=3（截断小数）

    // 2. 指针转换（无检查，风险高）
    int x = 100;
    double* dp = (double*)&x; // 强制将int指针转为double指针，取值会出错

    return 0;
}

3. C++专属安全转换运算符（推荐）

(1) static_cast：编译期安全转换

最常用的C++转换，仅支持类型兼容的转换，编译期检查合法性。

int main() {
    // 1. 基本类型转换（替代C风格，更清晰）
    double h = 99.9;
    int i = static_cast<int>(h); // i=99

    // 2. 相关类指针/引用转换（如父类→子类、子类→父类）
    class Base {};
    class Derived : public Base {};
    Base* base_ptr = new Derived();
    Derived* der_ptr = static_cast<Derived*>(base_ptr); // 子类→父类反向转换（需确保类型正确）

    // 3. 空指针转换
    void* void_ptr = static_cast<void*>(&i);
    int* int_ptr = static_cast<int*>(void_ptr);

    return 0;
}

适用场景：基本类型转换、上下转型（多态类建议用dynamic_cast）、void指针转换。

(2) reinterpret_cast：二进制重解释（极度谨慎）

直接操作内存二进制位，不做任何类型检查，仅用于底层编程。

int main() {
    // 1. 指针→整数转换（存储指针地址）
    int num = 123;
    int* ptr = #
    uint64_t addr = reinterpret_cast<uint64_t>(ptr); // 指针转整数，存储地址值
    cout << "指针地址：" << hex << addr << endl;

    // 2. 不相关类型指针转换（风险极高）
    double* d_ptr = reinterpret_cast<double*>(ptr); // 仅重解释二进制，取值无意义

    return 0;
}

适用场景：底层内存操作、硬件接口编程、指针地址序列化（极少用）。

(3) const_cast：移除/添加const属性

唯一能修改const属性的转换，仅作用于指针/引用，不能直接转换普通变量。

int main() {
    // 1. 移除const（谨慎：修改原const变量可能触发未定义行为）
    const int const_num = 100;
    int* non_const_ptr = const_cast<int*>(&const_num);
    *non_const_ptr = 200; // 若const_num在只读内存，会崩溃！

    // 2. 添加const
    int normal_num = 50;
    const int* const_ptr = const_cast<const int*>(&normal_num);

    return 0;
}

注意：仅建议在“函数参数需要非const，但实际不修改值”的场景使用，禁止修改原const变量。

(4) dynamic_cast：运行时类型检查（仅多态类）

仅用于包含虚函数的多态类，向下转型时会检查类型合法性，失败返回nullptr（指针）/抛异常（引用）。

class Base {
public:
    virtual void show() {} // 虚函数，开启多态
};

class Derived : public Base {
public:
    void show() override { cout << "Derived" << endl; }
};

int main() {
    Base* base_ptr = new Derived();
    // 向下转型：Base* → Derived*（运行时检查）
    Derived* der_ptr = dynamic_cast<Derived*>(base_ptr);
    if (der_ptr) { // 转换成功
        der_ptr->show(); // 输出Derived
    }

    Base* pure_base = new Base();
    Derived* err_ptr = dynamic_cast<Derived*>(pure_base);
    if (!err_ptr) { // 转换失败，返回nullptr
        cout << "转换失败" << endl;
    }

    delete base_ptr;
    delete pure_base;
    return 0;
}

核心优势：避免不安全的向下转型，是多态编程的安全选择。

三、C++类型转换避坑指南

1. 优先使用C++转换运算符：替代C风格转换，static_cast/dynamic_cast有编译/运行时检查，更安全；
2. 禁止滥用reinterpret_cast：仅底层编程使用，普通业务逻辑绝对避免；
3. const_cast仅临时移除const：不要修改原const变量，否则可能导致程序崩溃；
4. 隐式转换警惕精度丢失：如double→int、int→char，建议显式转换并校验；
5. 多态类转型用dynamic_cast：避免static_cast导致的类型错误。

总结

1. C++类型转换分隐式（自动）和显式（手动），显式转换优先用static_cast/dynamic_cast，避免C风格和reinterpret_cast；
2. const_cast仅用于修改const属性（谨慎），dynamic_cast专用于多态类的安全向下转型；
3. 转换的核心原则：尽量减少不必要的类型转换，必须转换时优先选择带检查的方式，降低运行时风险。