C++强制类型转换

C++提供了四种强制类型转换运算符，比C风格的转换更安全、更明确：

1. static_cast - 静态转换

最常用的转换，用于相关类型之间的转换（如数值类型、有继承关系的类指针）

// 基本类型转换
double d = 3.14;
int i = static_cast<int>(d);  // 3

// 向上转换（派生类指针/引用 -> 基类指针/引用）
class Base {};
class Derived : public Base {};

Derived* derived = new Derived();
Base* base = static_cast<Base*>(derived);  // 安全

// 向下转换（基类 -> 派生类）- 不检查类型安全
Base* base2 = new Derived();
Derived* derived2 = static_cast<Derived*>(base2);  // 不安全，需要程序员确保类型正确

// 隐式转换的显式写法
void* void_ptr = malloc(100);
int* int_ptr = static_cast<int*>(void_ptr);

// 非const转const
int x = 10;
const int& cx = static_cast<const int&>(x);

2. dynamic_cast - 动态转换

用于多态类型（有虚函数的类）之间的安全转换，会在运行时检查类型安全

class Animal {
public:
    virtual ~Animal() {}  // 必须有虚函数才能使用dynamic_cast
};

class Dog : public Animal {
public:
    void bark() { cout << "Woof!" << endl; }
};

class Cat : public Animal {
public:
    void meow() { cout << "Meow!" << endl; }
};

// 安全向下转换
Animal* animal = new Dog();

// 方法1：指针转换（失败返回nullptr）
Dog* dog = dynamic_cast<Dog*>(animal);
if (dog) {
    dog->bark();  // 安全调用
}

// 方法2：引用转换（失败抛出std::bad_cast异常）
try {
    Dog& dog_ref = dynamic_cast<Dog&>(*animal);
    dog_ref.bark();
} catch (const std::bad_cast& e) {
    cerr << "转换失败: " << e.what() << endl;
}

// 交叉转换（需要完整的继承关系信息）
Cat* cat = dynamic_cast<Cat*>(animal);  // 返回nullptr

// 检查类型
if (Dog* d = dynamic_cast<Dog*>(animal)) {
    // 是Dog类型
} else if (Cat* c = dynamic_cast<Cat*>(animal)) {
    // 是Cat类型
}

3. const_cast - 常量性转换

用于添加或移除const/volatile限定符

// 移除const
const int ci = 42;
int* modifiable = const_cast<int*>(&ci);  // 警告：修改ci是未定义行为！

// 正确使用场景：调用不接受const参数的旧API
void legacy_function(char* str) {
    // 修改字符串
}

const char* cstr = "Hello";
// legacy_function(cstr);  // 错误：无法将const char*转为char*
legacy_function(const_cast<char*>(cstr));  // 可能危险，但有时必要

// 添加const（通常不需要，因为可以隐式添加）
int x = 10;
const int* cptr = &x;  // 隐式转换即可
// const int* cptr2 = const_cast<const int*>(&x);  // 不必要的显示转换

// volatile转换
volatile int vi = 100;
int* normal = const_cast<int*>(&vi);  // 移除volatile

// 注意：const_cast不能改变类型本身，只能改变const/volatile属性

4. reinterpret_cast - 重新解释转换

最危险的转换，用于完全不相关类型之间的低级转换（如指针转整数、不同类型指针互转）

// 指针转整数（需要保证整数类型足够大）
int* ptr = new int(42);
uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);

// 整数转指针
int* ptr2 = reinterpret_cast<int*>(addr);

// 不同类型指针互转
struct Data {
    int a;
    double b;
};

Data data = {10, 3.14};
char* bytes = reinterpret_cast<char*>(&data);  // 查看内存布局

// 函数指针转换
typedef void (*FuncPtr)();
void my_func() { cout << "Hello" << endl; }

FuncPtr func = reinterpret_cast<FuncPtr>(my_func);

// 危险示例：访问私有成员
class Secret {
private:
    int secret_value = 42;
public:
    void print() { cout << secret_value << endl; }
};

Secret s;
int* stolen = reinterpret_cast<int*>(&s);  // 危险！访问私有成员
cout << *stolen << endl;  // 输出42

// 注意：很多reinterpret_cast使用会导致未定义行为

5. C风格转换 vs C++风格转换

// C风格转换：(type)value
double d = 3.14;
int i = (int)d;  // C风格

// 等价于（按顺序尝试）：
// 1. const_cast
// 2. static_cast
// 3. static_cast + const_cast
// 4. reinterpret_cast
// 5. reinterpret_cast + const_cast

// C++风格转换的优势：
// - 明确转换意图
// - 编译器检查更严格
// - 更容易搜索和审查

6. 使用建议和最佳实践

// 1. 优先使用static_cast
int a = 10;
double b = static_cast<double>(a);

// 2. 多态类型转换用dynamic_cast
class Base { virtual ~Base() = default; };
class Derived : public Base {};

Base* base = new Derived();
if (Derived* derived = dynamic_cast<Derived*>(base)) {
    // 安全使用derived
}

// 3. 避免使用const_cast修改真正的常量
const int REAL_CONST = 100;
// int* bad = const_cast<int*>(&REAL_CONST);  // 危险！
// *bad = 200;  // 未定义行为

// 4. 尽量避免reinterpret_cast
// 除非你知道自己在做什么，且有充分的理由

// 5. 使用类型安全的替代方案
template<typename T, typename U>
T safe_cast(U u) {
    static_assert(std::is_convertible<U, T>::value, 
                  "Types are not convertible");
    return static_cast<T>(u);
}

// 6. RTTI（运行时类型信息）使用
#include <typeinfo>

void print_type_info(const Base* obj) {
    if (obj) {
        cout << "Type: " << typeid(*obj).name() << endl;
        
        // 检查确切类型
        if (typeid(*obj) == typeid(Derived)) {
            cout << "It's a Derived object" << endl;
        }
    }
}

7. 常见应用场景

// 场景1：数值截断
float f = 3.99f;
int i = static_cast<int>(f);  // 3

// 场景2：多态容器处理
vector<Base*> objects;
objects.push_back(new Derived());

for (auto obj : objects) {
    if (auto derived = dynamic_cast<Derived*>(obj)) {
        derived->derived_method();
    }
}

// 场景3：序列化/反序列化
class Serializable {
public:
    virtual void serialize(char* buffer) = 0;
    virtual void deserialize(const char* buffer) = 0;
};

void save_to_file(Serializable* obj, const string& filename) {
    char buffer[1024];
    obj->serialize(buffer);
    // 将buffer写入文件
}

// 场景4：与C库交互
extern "C" {
    void c_function(void* data);
}

struct MyData { int x; double y; };
MyData data = {1, 2.5};
c_function(reinterpret_cast<void*>(&data));

总结

1. static_cast：用于相关类型转换，编译时检查
2. dynamic_cast：用于多态类型转换，运行时检查
3. const_cast：用于const/volatile属性修改
4. reinterpret_cast：用于低级、不相关类型转换

黄金法则：

• 优先使用static_cast
• 多态类型用dynamic_cast
• 尽量不用const_cast修改真正的常量
• 尽量避免reinterpret_cast
• 永远不使用C风格转换在新代码中