C++中五种类型转换的深度对比与实践指南

// 两种等价形式
(T)expression;    // 传统 C 风格
T(expression);    // 函数式语法（C++ 兼容）

// 1. 基本类型转换（合法但可能丢失精度）
double pi = 3.14159;
int pi_int = (int)pi;          // C 风格
int pi_int2 = int(pi);         // 函数式风格（等价）

// 2. 指针类型转换（不安全，无类型检查）
void* void_ptr = π
int* int_ptr = (int*)void_ptr; // void* → int*（编译通过，逻辑是否合法取决于实际指向）

// 3. 忽略 const 转换（编译通过，但修改会导致未定义行为）
const int num = 10;
int* mutable_num = (int*)#
*mutable_num = 20; // 未定义行为（num 本质是 const 对象）

static_cast<TargetType>(expression);

// 1. 基本类型转换（安全，显式声明意图）
double pi = 3.14159;
int pi_int = static_cast<int>(pi); // 显式转换，可读性优于 C 风格

// 2. 父子类上行转换（安全，编译器验证继承关系）
class Base {};
class Derived : public Base {};
Derived* derived_ptr = new Derived();
Base* base_ptr = static_cast<Base*>(derived_ptr); // 合法，Derived 是 Base 的子类

// 3. void* 与具体类型指针互转
int num = 10;
void* void_ptr = static_cast<void*>(&num); // int* → void*（安全）
int* int_ptr = static_cast<int*>(void_ptr); // void* → int*（需确保原类型是 int）

// 4. 枚举与整数互转
enum Color { Red = 1, Green = 2 };
Color color = static_cast<Color>(2); // 整数 → 枚举
int color_val = static_cast<int>(color); // 枚举 → 整数

dynamic_cast<TargetType>(expression);

#include <iostream>
#include <typeinfo> // 用于 std::bad_cast

class Base {
public:
    virtual void func() {} // 必须有虚函数（多态类）
};

class Derived : public Base {};
class Sibling : public Base {}; // 兄弟类

int main() {
    // 1. 下行转换（成功场景）
    Base* base_ptr = new Derived(); // 实际指向 Derived 对象
    Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
    if (derived_ptr != nullptr) {
        std::cout << "下行转换成功" << std::endl;
    }

    // 2. 下行转换（失败场景）
    base_ptr = new Base(); // 实际指向 Base 对象
    derived_ptr = dynamic_cast<Derived*>(base_ptr);
    if (derived_ptr == nullptr) {
        std::cout << "下行转换失败，返回 nullptr" << std::endl;
    }

    // 3. 引用转换（失败抛异常）
    Base& base_ref = *new Base();
    try {
        Derived& derived_ref = dynamic_cast<Derived&>(base_ref);
    } catch (const std::bad_cast& e) {
        std::cout << "引用转换失败：" << e.what() << std::endl;
    }

    // 4. 交叉转换（兄弟类转换，成功）
    Sibling* sibling_ptr = dynamic_cast<Sibling*>(new Derived());
    if (sibling_ptr == nullptr) {
        std::cout << "兄弟类转换失败" << std::endl; // 输出此句（Derived 不是 Sibling 子类）
    }

    return 0;
}

const_cast<TargetType>(expression);

#include <iostream>

void modify(int& x) {
    x = 100; // 非 const 函数，修改参数
}

int main() {
    // 1. 去除 const 限定（对象非本质常量，合法）
    int num = 20; // 非 const 对象
    const int* const_ptr = &num;
    int* mutable_ptr = const_cast<int*>(const_ptr);
    *mutable_ptr = 30;
    std::cout << num << std::endl; // 输出 30（合法）

    // 2. 去除 const 限定（对象是本质常量，修改导致 UB）
    const int const_num = 50; // 本质 const 对象
    int* bad_ptr = const_cast<int*>(&const_num);
    *bad_ptr = 60; // 未定义行为（可能输出 50 或 60，取决于编译器优化）
    std::cout << const_num << std::endl;

    // 3. 引用去除 const（调用非 const 函数）
    const int ref_num = 70;
    modify(const_cast<int&>(ref_num)); // 若 ref_num 是本质 const，修改 UB

    // 4. 添加 const 限定（合法，但可隐式转换，较少用）
    int* ptr = &num;
    const int* const_ptr2 = const_cast<const int*>(ptr);

    return 0;
}

reinterpret_cast<TargetType>(expression);

#include <cstdint> // 用于 uintptr_t

int main() {
    // 1. 指针与整数互转（底层地址操作）
    int num = 0x12345678;
    int* ptr = &num;
    uintptr_t addr = reinterpret_cast<uintptr_t>(ptr); // 指针 → 整数（存储地址）
    int* ptr2 = reinterpret_cast<int*>(addr); // 整数 → 指针（恢复地址）
    std::cout << *ptr2 << std::endl; // 输出 0x12345678（合法，需确保地址有效）

    // 2. 无关联指针互转（底层硬件交互场景）
    double pi = 3.14159;
    int* pi_int_ptr = reinterpret_cast<int*>(&pi); // double* → int*（重新解释比特位）
    // *pi_int_ptr 的值是 pi 的二进制比特位按 int 解析的结果，与平台相关

    // 3. 函数指针转换（底层调用场景）
    void func() { std::cout << "func called" << std::endl; }
    typedef int (*FuncType)();
    FuncType func_ptr = reinterpret_cast<FuncType>(func);
    // func_ptr(); // 未定义行为（返回值类型不匹配）

    return 0;
}