🎯 本节目标

1. 📖 C语言中的类型转换回顾
2. 🔄 C++四种强制类型转换详解
3. ❓ 为什么需要强制类型转换
4. 🔍 RTTI（运行时类型识别）
5. 💡 总结与面试题

📖 1. C语言中的类型转换回顾

在C语言中，当赋值运算符左右两侧类型不同、形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转换。C语言中总共有两种形式的类型转换：

🔧 1.1 隐式类型转换

编译器在编译阶段自动进行，能转就转，不能转就编译失败。

// 示例：隐式类型转换
int i = 10;
double d = i;  // int隐式转换为double
char c = 'A';
int ascii = c; // char隐式转换为int

🛠️ 1.2 显式类型转换

需要用户自己处理，使用强制类型转换操作符。

// 示例：显式类型转换
double pi = 3.14159;
int intPi = (int)pi;  // 强制转换为int，丢失小数部分

int* ptr = nullptr;
int address = (int)ptr;  // 指针转换为整数

⚠️ C语言类型转换的缺陷

1. 转换的可视性差：所有转换形式都以相同方式书写，难以跟踪错误的转换
2. 安全性不足：隐式转换可能导致数据精度丢失
3. 代码不够清晰：显式转换将所有情况混合在一起

🔄 2. C++四种强制类型转换详解

C++为了加强类型转换的可视性和安全性，引入了四种命名的强制类型转换操作符：

📊 类型转换对比表

转换类型	关键字	主要用途	安全性
静态转换	static_cast	相关类型间的转换	中等
重新解释	reinterpret_cast	不相关类型间的转换	低
常量转换	const_cast	移除const属性	低
动态转换	dynamic_cast	多态类型间的转换	高

🔧 2.1 static_cast（静态转换）

用于非多态类型的转换，编译器隐式执行的任何类型转换都可用static_cast。

• 非多态类型转换：不涉及继承关系和虚函数的类型转换，
• 编译器隐式类型转换：比如int到double，char到int的转换。

#include <iostream>
using namespace std;

int main() {
    // 示例1：基本类型转换
    double d = 12.34;
    int a = static_cast<int>(d);  // double -> int
    cout << "double转int: " << d << " -> " << a << endl;
    
    // 示例2：相关指针类型转换
    void* p = &a;
    int* q = static_cast<int*>(p);  // void* -> int*
    
    // 示例3：类层次结构中的向上转换
    class Base {};
    class Derived : public Base {};
    
    Derived derived;
    Base* basePtr = static_cast<Base*>(&derived);  // 向上转换
    
    return 0;
}

📝 注意事项：

• ✅ 可以用于相关类型间的转换
• ❌ 不能用于两个完全不相关的类型
• ⚠️ 不进行运行时类型检查

🔄 2.2 reinterpret_cast（重新解释转换）

为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型。

#include <iostream>
using namespace std;

int main() {
    // 示例1：整数与指针间的转换
    int value = 42;
    int* ptr = &value;
    
    // 将指针转换为整数（内存地址）
    uintptr_t address = reinterpret_cast<uintptr_t>(ptr);
    cout << "指针地址: " << hex << address << dec << endl;
    
    // 将整数转换回指针
    int* ptr2 = reinterpret_cast<int*>(address);
    cout << "指针值: " << *ptr2 << endl;
    
    // 示例2：不同类型指针间的转换
    struct Data {
        int x;
        int y;
    };
    
    Data data{10, 20};
    char* bytes = reinterpret_cast<char*>(&data);
    
    // 示例3：函数指针转换
    typedef void (*FuncPtr)();
    FuncPtr func = reinterpret_cast<FuncPtr>(address);
    
    return 0;
}

⚠️ 警告：

• 这是最危险的转换类型
• 不进行任何类型安全检查
• 应尽量避免使用，除非确实需要

🔓 2.3 const_cast（常量转换）

最常用的用途就是删除变量的const属性，方便赋值。

#include <iostream>
using namespace std;

void printValue(const int& value) {
    // 错误：不能修改const引用
    // value = 100;
    
    // 使用const_cast移除const属性
    int& mutableValue = const_cast<int&>(value);
    mutableValue = 100;
    
    cout << "修改后的值: " << value << endl;
}

void testConstCast() {
    // 示例1：修改const变量
    const int a = 2;
    cout << "原始值: " << a << endl;
    
    int* p = const_cast<int*>(&a);
    *p = 3;
    
    // 注意：修改const变量是未定义行为！
    cout << "修改后（未定义行为）: " << a << endl;
    cout << "通过指针访问: " << *p << endl;
    
    // 示例2：在非const函数中调用const函数
    class MyClass {
    public:
        void constFunc() const {
            // 需要修改成员变量时使用const_cast
            MyClass* self = const_cast<MyClass*>(this);
            self->counter++;
        }
        
        void nonConstFunc() {
            constFunc();  // 可以调用
        }
        
    private:
        mutable int counter = 0;  // 更好的做法：使用mutable
    };
}

int main() {
    testConstCast();
    return 0;
}

📝 最佳实践：

• 尽量避免使用const_cast
• 如果需要修改"逻辑上const"的成员变量，使用mutable关键字
• 注意：修改真正的const对象是未定义行为

🔄 2.4 dynamic_cast（动态转换）

用于将一个父类对象的指针/引用转换为子类对象的指针或引用。

#include <iostream>
#include <typeinfo>
using namespace std;

// 基类（必须包含虚函数）
class Animal {
public:
    virtual ~Animal() {}  // 虚析构函数
    virtual void makeSound() const {
        cout << "动物发出声音" << endl;
    }
};

// 派生类1
class Dog : public Animal {
public:
    void makeSound() const override {
        cout << "汪汪！" << endl;
    }
    
    void wagTail() {
        cout << "摇尾巴..." << endl;
    }
};

// 派生类2
class Cat : public Animal {
public:
    void makeSound() const override {
        cout << "喵喵！" << endl;
    }
    
    void climbTree() {
        cout << "爬树..." << endl;
    }
};

void processAnimal(Animal* animal) {
    // 尝试向下转型为Dog
    Dog* dog = dynamic_cast<Dog*>(animal);
    if (dog) {
        cout << "这是一只狗：" << endl;
        dog->makeSound();
        dog->wagTail();
        return;
    }
    
    // 尝试向下转型为Cat
    Cat* cat = dynamic_cast<Cat*>(animal);
    if (cat) {
        cout << "这是一只猫：" << endl;
        cat->makeSound();
        cat->climbTree();
        return;
    }
    
    cout << "未知动物类型" << endl;
}

int main() {
    cout << "=== dynamic_cast示例 ===" << endl;
    
    // 示例1：成功的向下转型
    Dog myDog;
    Animal* animalPtr = &myDog;
    processAnimal(animalPtr);
    
    cout << "\n示例2：失败的向下转型" << endl;
    Cat myCat;
    Animal* catPtr = &myCat;
    
    // 尝试将猫转换为狗（会失败）
    Dog* badCast = dynamic_cast<Dog*>(catPtr);
    if (!badCast) {
        cout << "转换失败：猫不能转换为狗" << endl;
    }
    
    cout << "\n示例3：使用引用（失败会抛出异常）" << endl;
    try {
        Dog& dogRef = dynamic_cast<Dog&>(*catPtr);
        dogRef.makeSound();
    } catch (const bad_cast& e) {
        cout << "引用转换失败: " << e.what() << endl;
    }
    
    return 0;
}

📝 dynamic_cast的特点：

1. 只能用于含有虚函数的类（多态类型）
2. 会进行运行时类型检查，安全可靠
3. 指针转换失败返回nullptr，引用转换失败抛出bad_cast异常
4. 向上转型（子类→父类）：自动进行，不需要dynamic_cast
5. 向下转型（父类→子类）：需要dynamic_cast，且会检查类型
   对于向下转型：要求父类指针或者引用指向或者引用的对象类型必须和要转换目标的类型一致，否者会报错（会检查转换是否合法）。

❓ 3. 为什么需要强制类型转换

🎯 3.1 类型安全的重要性

// 不安全的C风格转换
void* rawPtr = malloc(sizeof(int));
int* intPtr = (int*)rawPtr;  // 可能有问题

// 更安全的C++转换
int* safePtr = static_cast<int*>(rawPtr);  // 明确意图

🔍 3.2 代码可读性与维护性

// C风格：意图不明确
int result = (int)calculateValue();

// C++风格：明确转换类型
int result = static_cast<int>(calculateValue());  // 静态转换
int result = dynamic_cast<int>(calculateValue()); // 动态转换（如果适用）

⚠️ 3.3 避免常见错误

class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void specificMethod() {}
};

void process(Base* base) {
    // 错误：可能访问不存在的成员
    // Derived* derived = (Derived*)base;
    // derived->specificMethod();  // 如果base不是Derived，会崩溃
    
    // 正确：使用dynamic_cast进行安全检查
    Derived* derived = dynamic_cast<Derived*>(base);
    if (derived) {
        derived->specificMethod();  // 安全调用
    }
}

🔍 4. RTTI（运行时类型识别）

RTTI（Run-time Type Identification）允许程序在运行时获取对象的类型信息。

🛠️ 4.1 typeid运算符

#include <iostream>
#include <typeinfo>
using namespace std;

class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {};

void testTypeid() {
    Base* basePtr = new Derived();
    
    // 获取类型信息
    cout << "类型名称: " << typeid(*basePtr).name() << endl;
    
    // 类型比较
    if (typeid(*basePtr) == typeid(Derived)) {
        cout << "对象是Derived类型" << endl;
    }
    
    delete basePtr;
}

📊 4.2 decltype（C++11）

#include <iostream>
#include <vector>
using namespace std;

void testDecltype() {
    int x = 10;
    double y = 3.14;
    
    // 获取表达式类型
    decltype(x + y) z = x + y;  // z的类型是double
    
    cout << "z的类型: " << typeid(z).name() << endl;
    cout << "z的值: " << z << endl;
    
    // 用于模板编程
    vector<int> vec{1, 2, 3};
    decltype(vec.begin()) it = vec.begin();
    
    // 用于lambda表达式
    auto lambda = [](int a, int b) -> decltype(a + b) {
        return a + b;
    };
    
    cout << "lambda结果: " << lambda(5, 3) << endl;
}

🔄 4.3 RTTI的完整示例

#include <iostream>
#include <typeinfo>
#include <memory>
using namespace std;

class Shape {
public:
    virtual ~Shape() {}
    virtual void draw() const = 0;
};

class Circle : public Shape {
public:
    void draw() const override {
        cout << "绘制圆形" << endl;
    }
    
    void setRadius(double r) {
        radius = r;
    }
    
private:
    double radius;
};

class Square : public Shape {
public:
    void draw() const override {
        cout << "绘制正方形" << endl;
    }
    
    void setSide(double s) {
        side = s;
    }
    
private:
    double side;
};

void processShape(Shape* shape) {
    cout << "\n=== 处理形状 ===" << endl;
    
    // 1. 使用typeid获取类型信息
    cout << "类型: " << typeid(*shape).name() << endl;
    
    // 2. 使用dynamic_cast进行安全转换
    if (Circle* circle = dynamic_cast<Circle*>(shape)) {
        cout << "这是一个圆形" << endl;
        circle->setRadius(5.0);
    } else if (Square* square = dynamic_cast<Square*>(shape)) {
        cout << "这是一个正方形" << endl;
        square->setSide(4.0);
    }
    
    // 3. 调用虚函数
    shape->draw();
}

int main() {
    Circle circle;
    Square square;
    
    processShape(&circle);
    processShape(&square);
    
    return 0;
}

💡 5. 总结与最佳实践

📋 5.1 四种转换的使用场景总结

场景	推荐转换	说明
基本类型转换	static_cast	int→double, float→int等
类层次向上转换	static_cast	派生类指针→基类指针
类层次向下转换	dynamic_cast	基类指针→派生类指针（多态）
移除const属性	const_cast	修改逻辑const成员
不相关类型转换	reinterpret_cast	指针→整数，函数指针转换
类型安全检查	dynamic_cast	运行时类型检查

🚨 5.2 注意事项与警告

1. 避免不必要的转换：优先考虑设计更好的接口
2. 明确转换意图：使用合适的转换操作符
3. 注意安全性：reinterpret_cast和const_cast可能引入未定义行为
4. 启用RTTI：dynamic_cast需要编译器启用RTTI支持
5. 性能考虑：dynamic_cast有运行时开销

🎯 5.3 编码规范建议

// 好的实践
double value = getDoubleValue();
int intValue = static_cast<int>(value);  // 明确意图

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

// 避免的实践
int* p = (int*)malloc(sizeof(int));  // C风格，不推荐
int* p = reinterpret_cast<int*>(malloc(sizeof(int)));  // 过于底层

📝 6. 经典面试题与解答

❓ 面试题1：C++中的4种类型转换是什么？

答案：
C++提供了四种命名的强制类型转换操作符：

1. static_cast：用于非多态类型的转换，编译器隐式执行的类型转换
2. reinterpret_cast：为操作数的位模式提供较低层次的重新解释
3. const_cast：用于修改类型的const或volatile属性
4. dynamic_cast：用于多态类型之间的转换，会进行运行时类型检查

❓ 面试题2：说说4种类型转换的应用场景

答案：

1. static_cast应用场景：

   • 基本数据类型之间的转换（int→double）
   • 类层次结构中的向上转换（派生类→基类）
   • 空指针转换为目标类型的空指针

2. reinterpret_cast应用场景：

   • 指针和整数之间的转换
   • 不同类型指针之间的转换
   • 函数指针之间的转换

3. const_cast应用场景：

   • 移除const属性调用非const函数
   • 修改逻辑上const的成员变量（配合mutable更好）

4. dynamic_cast应用场景：

   • 多态类型的安全向下转换
   • 运行时类型识别和检查
   • 实现基于类型的多态处理

❓ 面试题3：dynamic_cast和static_cast在向下转型时的区别

答案：

class Base { virtual void foo() {} };
class Derived : public Base {};

Base* basePtr = new Base();

// static_cast：不进行运行时检查，危险！
Derived* derived1 = static_cast<Derived*>(basePtr);  // 可能出错

// dynamic_cast：进行运行时检查，安全！
Derived* derived2 = dynamic_cast<Derived*>(basePtr);  // 返回nullptr

区别：

1. 安全性：dynamic_cast进行运行时检查，失败返回nullptr；static_cast不检查。
2. 适用范围：dynamic_cast只能用于多态类型（有虚函数）；static_cast可用于非多态类型。
3. 性能：dynamic_cast有运行时开销；static_cast在编译时完成。
4. 错误处理：dynamic_cast指针失败返回nullptr。