dynamic_cast和static_cast和const

`dynamic_cast` 在 C++ 中的作用

dynamic_cast 是 C++ 运行时类型转换（RTTI, Run-Time Type Identification）的一部分，主要用于：

安全的多态类型转换
检查类型的有效性
向下转换（Downcasting）
跨类层次的指针或引用转换

它只能用于 带有虚函数的类，否则 dynamic_cast 将无法工作。

1. `dynamic_cast` 的作用

1.1 向下转换（Downcasting）

用于将 基类（Base Class）指针/引用 转换为 派生类（Derived Class）指针/引用，并在运行时 检查类型安全性。

示例：

#include <iostream>
using namespace std;class Base {
public:virtual void show() { cout << "Base class\n"; } // 需要虚函数
};class Derived : public Base {
public:void show() override { cout << "Derived class\n"; }
};int main() {Base* basePtr = new Derived(); // 基类指针指向派生类对象// 使用 dynamic_cast 进行向下转换Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);if (derivedPtr) {derivedPtr->show(); // ✅ 成功转换并调用 Derived::show()} else {cout << "Conversion failed\n";}delete basePtr;return 0;
}

输出：

Derived class

✅ dynamic_cast 成功转换，因为 basePtr 实际指向的是 Derived 对象。

1.2 失败情况

如果 basePtr 实际上指向的是 Base 类型的对象，而不是 Derived，那么转换会失败，返回 nullptr（对于指针）。

Base* basePtr = new Base();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);if (derivedPtr) {derivedPtr->show();
} else {cout << "Conversion failed\n"; // ✅ 这里转换失败
}

输出：

Conversion failed

2. `dynamic_cast` 适用于引用

dynamic_cast 也可以用于 引用转换，但如果转换失败，会抛出 std::bad_cast 异常。

#include <iostream>
#include <typeinfo>
using namespace std;class Base { public: virtual ~Base() {} };
class Derived : public Base {};int main() {Base baseObj;try {Derived& derivedRef = dynamic_cast<Derived&>(baseObj); // ❌ 失败，抛出异常} catch (const std::bad_cast& e) {cout << "Exception: " << e.what() << endl;}return 0;
}

输出：

Exception: std::bad_cast

✅ 由于 baseObj 不是 Derived 类型，dynamic_cast 失败并抛出 std::bad_cast 异常。

3. `dynamic_cast` 和 `static_cast` 的区别

比较项	`dynamic_cast`	`static_cast`
转换类型	仅限于带虚函数的多态类	任何相关类型
运行时检查	✅ 有类型检查（RTTI）	❌ 无类型检查
失败情况	指针返回 `nullptr`，引用抛出 `std::bad_cast`	可能导致未定义行为
转换方向	只能用于向下转换	向上、向下转换均可
性能	运行时开销较大（涉及 RTTI 查询）	编译时转换，无额外开销

示例：`static_cast` vs `dynamic_cast`

Base* basePtr = new Base();// static_cast（不会进行检查，可能导致未定义行为）
Derived* derivedPtr1 = static_cast<Derived*>(basePtr); // ❌ 可能出现未定义行为
derivedPtr1->show(); // 可能崩溃// dynamic_cast（安全，但可能返回 nullptr）
Derived* derivedPtr2 = dynamic_cast<Derived*>(basePtr); // ✅ 失败时返回 nullptr
if (derivedPtr2) derivedPtr2->show();

总结：

dynamic_cast 安全但慢，适合 不确定基类指针实际指向的对象类型 时。
static_cast 快但危险，仅适合 明确知道转换是安全的情况下。

4. 什么时候使用 `dynamic_cast`？

✅ 使用 dynamic_cast 的最佳场景

向下转换（基类指针/引用 → 派生类指针/引用）。
运行时类型检查（避免 static_cast 可能的未定义行为）。
接口类（如 Base* ptr 指向某个不确定类型的派生类，需要判断其类型）。

❌ 避免 dynamic_cast 的情况

不涉及多态（没有 virtual 函数，dynamic_cast 无法工作）。
已知类型安全的转换（可用 static_cast 代替）。
高性能场景（dynamic_cast 有运行时开销）。

5. `dynamic_cast` 在实际应用中的示例

5.1 多态事件处理

class Event { public: virtual ~Event() {} };
class MouseEvent : public Event { public: void click() { cout << "Mouse clicked\n"; } };
class KeyboardEvent : public Event { public: void press() { cout << "Key pressed\n"; } };void handleEvent(Event* event) {if (MouseEvent* mouse = dynamic_cast<MouseEvent*>(event)) {mouse->click();} else if (KeyboardEvent* key = dynamic_cast<KeyboardEvent*>(event)) {key->press();} else {cout << "Unknown event\n";}
}int main() {MouseEvent mouse;KeyboardEvent keyboard;handleEvent(&mouse);    // ✅ 输出 "Mouse clicked"handleEvent(&keyboard); // ✅ 输出 "Key pressed"return 0;
}

✅ dynamic_cast 允许在运行时确定事件的类型，并调用相应的处理逻辑。

`const_cast` 在 C++ 中的作用

const_cast 是 C++ 提供的 四种类型转换运算符（static_cast、dynamic_cast、const_cast、reinterpret_cast）之一，专门用于去掉或添加 const / volatile 限定符。

它允许：

移除 const 限定符（常见用途）
移除 volatile 限定符
添加 const（几乎没用）

1. `const_cast` 的基本用法

1.1 去掉 `const` 修饰符

通常，const_cast 用于将 const 指针转换为非 const 指针，从而允许修改 const 变量（⚠️ 仅适用于非常量对象）。

示例：

#include <iostream>
using namespace std;void modifyConstValue(const int* ptr) {int* modifiablePtr = const_cast<int*>(ptr); // 去掉 const 限定符*modifiablePtr = 42; // 现在可以修改它
}int main() {int x = 10;modifyConstValue(&x);cout << "x = " << x << endl; // ✅ 输出 x = 42return 0;
}

输出：

x = 42

✅ const_cast<int*> 移除了 ptr 的 const 限定符，使得 modifiablePtr 可以修改 x。

2. `const_cast` 使用的注意事项

2.1 `const_cast` 不能修改真正的 `const` 变量

如果你试图修改一个 真正的 const 变量，行为是 未定义的（UB, Undefined Behavior）。

示例（错误）：

const int y = 100;
int* ptr = const_cast<int*>(&y);
*ptr = 200; // ❌ 未定义行为
cout << "y = " << y << endl;

⚠️ 即使编译通过，运行结果可能是：

y = 100  // ❌ 修改失败（某些编译器可能优化 `y` 为常量）

或

y = 200  // ❌ 可能错误修改（取决于编译器）

为什么？

const int y = 100; 可能会被编译器优化到只读存储区，因此试图修改它可能导致 程序崩溃 或 无效修改。

✅ 正确的使用方式：
const_cast 只能用于去掉 const 修饰符的指针/引用，而不能用于真正的 const 变量。

3. `const_cast` 用于函数参数

3.1 `const_cast` 解除 `const` 限定

有时，我们在 只接受非 const 参数的旧 C 库 中，需要传递 const 变量，这时 const_cast 可以解决问题。

#include <iostream>
using namespace std;void legacyFunction(char* str) { // 旧 C 库接口，必须接收非 conststr[0] = 'H'; // 修改字符串
}void wrapperFunction(const char* str) {legacyFunction(const_cast<char*>(str)); // 去掉 const
}int main() {char text[] = "hello";wrapperFunction(text);cout << text << endl; // ✅ 输出 "Hello"return 0;
}

✅ const_cast<char*> 允许 legacyFunction() 修改字符串。

4. `const_cast` 用于成员函数

在 C++ 类中，const_cast 可用于 在 const 成员函数中修改成员变量。

4.1 修改 `mutable` 变量

如果某个成员变量在 const 方法中需要修改，推荐使用 mutable，而不是 const_cast。

class Example {
private:mutable int counter = 0;
public:void increaseCounter() const {counter++; // ✅ 因为 counter 是 mutable，可以在 const 方法中修改}
};

✅ mutable 是更好的选择！

4.2 `const_cast` 在 `const` 方法中修改成员变量

如果不能使用 mutable，可以用 const_cast 强行去掉 const。

class Example {
private:int counter = 0;
public:void modify() const {const_cast<Example*>(this)->counter = 100; // 去掉 const 限定符}
};

⚠️ 注意：这会破坏 const 语义，最好避免！

5. `const_cast` 与其他类型转换的区别

转换方式	用途
`const_cast`	仅用于去掉或添加 `const`/`volatile`
`static_cast`	编译时转换，用于普通类型转换
`dynamic_cast`	运行时类型转换，用于多态类
`reinterpret_cast`	低级别强制转换，用于不同类型的二进制转换

6. 什么时候应该使用 `const_cast`？

✅ 适用场景

调用旧 C 库时，避免 const 兼容性问题（如 const char* 转 char*）。
在 const 成员函数中修改成员变量（但推荐 mutable）。
特定场景下移除 const 以提高灵活性（如优化某些代码）。

❌ 不推荐使用的情况

试图修改真正的 const 变量（未定义行为）。
滥用 const_cast 破坏 const 语义（影响代码可读性）。
可以使用 mutable 代替的情况。

7. `const_cast` 适用的真实案例

案例：日志系统

在 log() 方法中，可能希望在 const 对象中增加日志计数：

class Logger {
private:mutable int log_count = 0;
public:void log(const string& msg) const {cout << "Log: " << msg << endl;const_cast<Logger*>(this)->log_count++; // ✅ 修改 log_count}
};