一步步了解C++类型转换：static_cast、const_cast、reinterpret_cast和dynamic_cast

1. static_cast

static_cast 可以用于基础类型之间的转换，类层次结构中的父类和子类之间的转换，以及把 void* 转换成目标类型的指针等。

静态类型转换示例：

#include <iostream>

class Base {};
class Derived : public Base {};

int main() {
    // 基础数据类型
    int a = 10;
    double b = static_cast<double>(a); // int 转 double
    std::cout << "b: " << b << std::endl;

    // 类层次结构转换
    Derived derived;
    Base* basePtr = static_cast<Base*>(&derived); // 上行转换，安全
    Derived* derivedPtr = static_cast<Derived*>(basePtr); // 下行转换，不安全

    // void* 转目标类型指针
    void* voidPtr = &a;
    int* intPtr = static_cast<int*>(voidPtr); // 不安全
    std::cout << "*intPtr: " << *intPtr << std::endl;

    return 0;
}

2. const_cast

const_cast 用于移除 const 或 volatile 修饰符，常用于指针或引用。

常量类型转换示例：

#include <iostream>

void printNumber(const int* num) {
    // 去除 const 修饰
    int* modifiableNum = const_cast<int*>(num);
    *modifiableNum = 20; // 修改值
    std::cout << "Modified number: " << *modifiableNum << std::endl;
}

int main() {
    const int num = 10;
    printNumber(&num); // 打印和修改 num
    std::cout << "Original number: " << num << std::endl; // 打印原始 num（行为未定义）
    return 0;
}

3. reinterpret_cast

reinterpret_cast 可以将一个指针转换为一个整数，或者将一个整数转换为一个指针，还能在不同类型指针之间转换。

重新解释类型转换示例：

#include <iostream>

int main() {
    int a = 10;
    // 指针转整数，再转回指针
    intptr_t intPtrValue = reinterpret_cast<intptr_t>(&a);
    int* intPtr = reinterpret_cast<int*>(intPtrValue);
    std::cout << "*intPtr: " << *intPtr << std::endl;

    // 不同类型指针转换
    float* floatPtr = reinterpret_cast<float*>(&a);
    std::cout << "*floatPtr: " << *floatPtr << std::endl; // 输出未定义

    return 0;
}

4. dynamic_cast

dynamic_cast 主要用于类层次结构中的安全向下转换。它会进行运行时类型检查，需要虚函数支持。

动态类型转换示例：

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() {} // 必须有虚函数支持 RTTI
};

class Derived : public Base {};

int main() {
    Base* basePtr = new Derived; // 基本类型指针指向子类对象

    // 安全向下转换
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        std::cout << "Downcast successful" << std::endl;
    } else {
        std::cout << "Downcast failed" << std::endl;
    }

    // 错误向下转换
    Base* anotherBasePtr = new Base;
    derivedPtr = dynamic_cast<Derived*>(anotherBasePtr);
    if (derivedPtr) {
        std::cout << "Downcast successful" << std::endl;
    } else {
        std::cout << "Downcast failed" << std::endl;
    }

    delete basePtr;
    delete anotherBasePtr;

    return 0;
}

总结

• static_cast：主要用于基本类型转换和类层次结构中的上行或下行转换。
• const_cast：移除 const 或 volatile 修饰符，主要用于指针或引用类型。
• reinterpret_cast：重新解释类型转换，用于转换指针和整数以及不同类型的指针。
• dynamic_cast：用于类层次结构中的安全向下转换，依赖运行时类型信息。

这些类型转换运算符各自有不同的适用场景和安全性，使用时需要谨慎