static_cast在编译时进行类型转换，适用于已知安全的转换，如数值类型转换和类的上行转型；dynamic_cast在运行时通过RTTI检查类型，用于多态类的安全向下转型，转换失败返回nullptr或抛出异常，更安全但有性能开销。
C++中进行类型转换，主要有四种显式的转换方式：
static_cast
、
dynamic_cast
、
const_cast
和
reinterpret_cast
。其中，
static_cast
主要用于执行编译时已知的、相对安全的类型转换，比如数值类型转换、类层次结构中的上下行转换（前提是你知道转换是安全的）。而
dynamic_cast
则是一个运行时检查的转换工具，它专门用于处理多态类层次结构中的安全向下转型（downcasting），如果转换不安全，它会返回空指针或抛出异常，因此它比
static_cast
在某些场景下更安全。
在C++里，类型转换这回事儿，说实话，是个既强大又容易出岔子的地方。我们手里有几把不同的“锤子”，每把都有它擅长敲的“钉子”。
static_cast
，我觉得它就像一个“知情者”的转换。当你明确知道一个类型可以安全地转换成另一个类型时，比如把一个
int
转成
double
，或者在一个继承体系里，把一个派生类指针转换成基类指针（向上转型，这是安全的），甚至把基类指针转换成派生类指针（向下转型，但这里你要自己保证实际对象确实是派生类，否则就危险了），你就可以用它。它的检查是在编译时进行的，所以运行时没有额外的开销。
class Base {public: void func() { /* ... */ }};class Derived : public Base {public: void derivedFunc() { /* ... */ }};// 示例1：基本类型转换int i = 10;double d = static_cast(i); // 编译时安全转换// 示例2：向上转型 (安全)Derived* pd = new Derived();Base* pb = static_cast(pd); // 编译时安全转换// 示例3：向下转型 (需要程序员保证安全)Base* pb2 = new Derived(); // 实际是Derived对象Derived* pd2 = static_cast(pb2); // 编译时通过，运行时如果pb2不是Derived类型，行为未定义！Base* pb3 = new Base(); // 实际是Base对象// Derived* pd3 = static_cast(pb3); // 编译时通过，运行时这里会出问题！pb3不是Derived
dynamic_cast
，这玩意儿就显得“谨慎”多了。它只作用于带有虚函数的类（也就是多态类），主要目的是在运行时安全地进行向下转型。当你想把一个基类指针或引用转换成派生类指针或引用时，它会在运行时检查实际对象的类型。如果转换是合法的，它就成功；如果不是，对于指针类型，它会返回
nullptr
；对于引用类型，它会抛出
std::bad_cast
异常。这种运行时检查的代价就是它会有一些性能开销，但它换来了安全性。
立即学习“C++免费学习笔记（深入）”；
#include #include // For std::bad_castclass Base {public: virtual ~Base() {} // 必须有虚函数才能使用dynamic_cast virtual void func() { std::cout << "Base::func" << std::endl; }};class Derived : public Base {public: void func() override { std::cout << "Derived::func" << std::endl; } void derivedFunc() { std::cout << "Derived::derivedFunc" << std::endl; }};// 示例：dynamic_castBase* b1 = new Derived(); // b1实际指向Derived对象if (Derived* d1 = dynamic_cast(b1)) { d1->derivedFunc(); // 安全调用} else { std::cout << "Conversion failed for b1" << std::endl;}Base* b2 = new Base(); // b2实际指向Base对象if (Derived* d2 = dynamic_cast(b2)) { d2->derivedFunc(); // 不会执行，d2为nullptr} else { std::cout << "Conversion failed for b2" << std::endl; // 输出此行}// 引用类型的dynamic_castDerived obj_derived;Base& ref_base_derived = obj_derived;try { Derived& ref_derived = dynamic_cast(ref_base_derived); ref_derived.derivedFunc();} catch (const std::bad_cast& e) { std::cout << "Bad cast for ref_base_derived: " << e.what() << std::endl;}Base obj_base;Base& ref_base = obj_base;try { Derived& ref_derived = dynamic_cast(ref_base); // 这里会抛出std::bad_cast ref_derived.derivedFunc();} catch (const std::bad_cast& e) { std::cout << "Bad cast for ref_base: " << e.what() << std::endl; // 输出此行}delete b1;delete b2;
还有
const_cast
，它唯一的作用是添加或移除对象的
const
或
volatile
属性。这东西用起来要特别小心，因为你可能在尝试修改一个原本是常量的数据，那可是未定义行为。
最后是
reinterpret_cast
，这是最暴力、最底层的转换。它基本上就是告诉编译器：“别管了，把这块内存按我说的类型解释！”它不进行任何类型检查，通常用于底层操作，比如把一个指针转换成一个整数，或者在不相关的类型之间进行位模式的转换。这玩意儿风险极高，通常只有在特定、明确的底层需求下才考虑使用，否则基本是给自己挖坑。
static_cast
static_cast
与
dynamic_cast
的核心区别是什么？
在我看来，它们最根本的区别在于“何时”以及“如何”进行类型检查。
static_cast
是在编译时完成转换的，它不涉及任何运行时类型检查。你可以把它想象成编译器相信你已经知道你在做什么，它只是按照你的指示进行类型上的调整。这意味着，如果你的转换逻辑在运行时是错误的（比如你把一个实际上是基类对象的指针强转成了派生类指针），
static_cast
不会告诉你，它会让你在运行时遇到未定义行为，这往往导致程序崩溃或产生难以追踪的bug。
而
dynamic_cast
则完全不同。它是一个运行时操作符，它依赖于C++的运行时类型信息（RTTI）。这意味着，当你使用
dynamic_cast
时，程序会在运行时检查实际对象的类型，以确保转换是安全的。只有当源指针/引用确实指向目标类型的对象，或者目标类型是源类型的一个基类时，转换才会成功。这种运行时检查是它安全性的来源，但也带来了额外的性能开销。此外，
dynamic_cast
只能用于多态类层次结构，也就是说，基类中至少要有一个虚函数，这样才能启用RTTI。如果不是多态类，
dynamic_cast
就无法使用。
简单来说，
static_cast
是“我相信你”，
dynamic_cast
是“我先检查一下”。
什么时候应该优先使用
static_cast
static_cast
？
我觉得，当你对类型转换有绝对的把握，并且这种转换在逻辑上是“自然”的时候，
static_cast
就是你的首选。
比如，你正在进行数值类型之间的转换，像把
int
转成
float
，或者把
double
转成
int
（当然，后者会丢失精度，但这是你明确知道并接受的）。再比如，在类继承体系中进行向上转型，也就是把派生类指针或引用转换为基类指针或引用。这是完全安全的，因为派生类天然就是基类的一种。
// 示例：向上转型，使用static_cast是惯例且安全Derived d_obj;Base* b_ptr = static_cast(&d_obj); // 总是安全的Base& b_ref = static_cast(d_obj); // 总是安全的
另一个常见场景是，当你有一个
void*
指针，你知道它实际指向的是什么类型的对象时，你需要把它转换回原来的类型。这也是
static_cast
的用武之地。
void* raw_ptr = new int(42);int* i_ptr = static_cast(raw_ptr); // 知道raw_ptr实际指向intstd::cout << *i_ptr << std::endl;delete static_cast(raw_ptr); // 释放内存
此外，如果你需要显式地调用一个单参数构造函数来完成类型转换，
static_cast
也能派上用场。总而言之，当你追求性能，并且已经通过设计或逻辑确保了类型转换的安全性时，
static_cast
是更简洁、更高效的选择。它就像是告诉编译器：“嘿，我知道我在做什么，别多管闲事，直接转！”
什么时候必须使用
dynamic_cast
dynamic_cast
？
当你需要在运行时，安全地将一个基类指针或引用转换为派生类指针或引用时，
dynamic_cast
是你的不二之选，甚至可以说是“必须”使用。
这通常发生在多态的场景中，比如你有一个基类指针，它可能指向基类对象，也可能指向任何一个派生类对象。而你现在需要调用某个派生类特有的方法。这时候，你就不能简单地用
static_cast
了，因为如果实际对象不是你期望的派生类类型，
static_cast
会让你在运行时掉进坑里。
dynamic_cast
则会替你检查，如果转换失败，它会给你一个明确的信号（
nullptr
或
std::bad_cast
），让你有机会处理这种失败情况，而不是直接崩溃。
// 假设我们有一个处理基类指针的函数void processObject(Base* obj) { if (Derived* d_obj = dynamic_cast(obj)) { // 只有当obj确实是Derived或其派生类时，这里才会被执行 d_obj->derivedFunc(); } else { std::cout << "Object is not of type Derived." <func(); // 调用基类方法 }}// 在main函数中调用// Derived* my_derived = new Derived();// Base* my_base = new Base();// processObject(my_derived); // 成功转换为Derived并调用derivedFunc// processObject(my_base); // 转换失败，调用Base::func
这种运行时类型识别的能力，对于构建灵活、健壮的面向对象系统至关重要。比如，你可能有一个插件系统，所有插件都实现一个共同的接口（基类），但每个插件可能还有自己独特的子类功能。当你在运行时加载一个插件时，你需要判断它是否支持某个特定的子功能，这时
dynamic_cast
就能派上用场。它允许你根据对象的实际类型来调整程序的行为，而不是仅仅依赖于编译时的声明类型。简而言之，当你不确定对象的真实类型，但又需要访问其特定派生类功能时，
dynamic_cast
就是你的救星。
以上就是C++类型转换有哪些方式 static_cast dynamic_cast区别的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1471772.html
微信扫一扫 
支付宝扫一扫 
