什么时候应该使用 static_cast、dynamic_cast、const_cast 和 reinterpret_cast？

港控/mmm° 2024-03-30 12:11 56阅读 0赞

## 问： ##

什么是正确的用途：

static\_cast

dynamic\_cast

const\_cast

reinterpret\_cast

(type)value (C 风格转换)

type(value) （函数式转换）

如何决定在哪些特定情况下使用哪个？

## 答1: ##

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

static\_cast 是您应该尝试使用的第一个演员表。它执行诸如类型之间的隐式转换（例如 int 到 float 或指向 void\* 的指针）之类的事情，它还可以调用显式转换函数（或隐式转换函数）。在许多情况下，不需要显式声明 static\_cast，但重要的是要注意 T(something) 语法等效于 (T)something 并且应该避免使用（稍后会详细介绍）。然而，T(something, something\_else) 是安全的，并保证调用构造函数。

static\_cast 也可以通过继承层次结构进行转换。向上转换（朝向基类）时没有必要，但向下转换时可以使用它，只要它不通过 virtual 继承进行转换即可。但是，它不进行检查，static\_cast 将层次结构向下到实际上不是对象类型的类型是未定义的行为。

const\_cast 可用于将 const 删除或添加到变量中；没有其他 C++ 演员能够删除它（甚至 reinterpret\_cast）。重要的是要注意修改以前的 const 值只有在原始变量是 const 时才被定义；如果您使用它来取消 const 对未使用 const 声明的内容的引用，则它是安全的。例如，这在基于 const 重载成员函数时很有用。它也可以用于将const添加到对象中，例如调用成员函数重载。

const\_cast 在 volatile 上也有类似的作用，尽管这种情况不太常见。

dynamic\_cast 专门用于处理多态性。您可以将指向任何多态类型的指针或引用强制转换为任何其他类类型（多态类型至少有一个声明或继承的虚函数）。您不仅可以将其用于向下投射 - 您还可以向侧面投射，甚至可以向上投射另一条链。 dynamic\_cast 将寻找所需的对象并在可能的情况下返回它。如果不能，它会在指针的情况下返回 nullptr，或者在引用的情况下抛出 std::bad\_cast。

但是，dynamic\_cast 有一些限制。如果继承层次结构中有多个相同类型的对象（所谓的“可怕的菱形”）并且您没有使用 virtual 继承，则它不起作用。它也只能通过公共继承 - 它总是无法通过 protected 或 private 继承。然而，这很少成为问题，因为这种继承形式很少见。

reinterpret\_cast 是最危险的演员表，应该非常谨慎地使用。它将一种类型直接转换为另一种类型——例如将值从一个指针转换为另一个，或将指针存储在 int 中，或各种其他令人讨厌的事情。很大程度上，您使用 reinterpret\_cast 获得的唯一保证是，通常如果您将结果转换回原始类型，您将获得完全相同的值（但 如果中间类型小于原始类型）。 reinterpret\_cast 也无法进行许多转换。它主要用于特别奇怪的转换和位操作，例如将原始数据流转换为实际数据，或将数据存储在指向对齐数据的指针的低位中。

C-style cast 和 function-style cast 分别是使用 (type)object 或 type(object) 进行的强制转换，并且在功能上是等效的。它们被定义为以下成功的第一个：

const\_cast

static\_cast（尽管忽略了访问限制）

static\_cast（见上文），然后是 const\_cast

reinterpret\_cast

重新解释\_cast，然后是 const\_cast

因此，在某些情况下，它可以用作其他类型转换的替代品，但由于能够演变为 reinterpret\_cast，因此非常危险，并且在需要显式转换时应该首选后者，除非您确定 \{2 \} 将成功或 reinterpret\_cast 将失败。即便如此，考虑更长、更明确的选项。

C 风格的转换在执行 static\_cast 时也会忽略访问控制，这意味着它们能够执行其他转换无法执行的操作。不过，这主要是一个杂物，在我看来，这只是避免 C 风格转换的另一个原因。

`dynamic_cast 仅适用于多态类型。您只需要在转换为派生类时使用它。除非您特别需要 dynamic_cast 的功能，否则 static_cast 肯定是第一个选项。一般来说，这不是一些神奇的银弹“类型检查演员”。`

`很好的答案！一个简短的评论：如果您将 Derived*& 转换为 Base*&，则可能需要 static_cast 来转换层次结构，因为双指针/引用不会自动转换层次结构。两分钟前我遇到了这种（坦率地说，不常见的）情况。 ;-)`

`*“没有其他 C++ 演员能够删除 const（甚至 reinterpret_cast）”......真的吗？ reinterpret_cast(reinterpret_cast(static_cast(0))) 呢？`

`我认为上面缺少的一个重要细节是 dynamic_cast 与 static 或 reinterpret_cast 相比具有运行时性能损失。这很重要，例如在实时软件中。`

`值得一提的是，在处理 API 的一组不透明数据类型时，reinterpret_cast 通常是首选武器`

## 答2: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

使用 dynamic\_cast 在继承层次结构中转换指针/引用。

使用 static\_cast 进行普通类型转换。

使用 reinterpret\_cast 对位模式进行低级重新解释。使用时要格外小心。

使用 const\_cast 来抛弃 const/volatile。避免这种情况，除非您使用 const 不正确的 API 被卡住。

`小心使用 dynamic_cast。它依赖于 RTTI，这将无法跨共享库边界按预期工作。仅仅因为您独立构建可执行文件和共享库，因此没有标准化的方法可以在不同构建之间同步 RTTI。由于这个原因，在 Qt 库中存在 qobject_cast<>，它使用 QObject 类型信息来检查类型。`

## 答3: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

（上面已经给出了很多理论和概念上的解释）

下面是我使用 static\_cast、dynamic\_cast、const\_cast、reinterpret\_cast 时的一些实际示例。

（也可以参考this来理解解释：http://www.cplusplus.com/doc/tutorial/typecasting/）

静态转换：

OnEventData(void* pData)
    
    {
        
      ......
    
      //  pData is a void* pData, 
    
      //  EventData is a structure e.g. 
      //  typedef struct _EventData {
        
      //  std::string id;
      //  std:: string remote_id;
      //  } EventData;
    
      // On Some Situation a void pointer *pData
      // has been static_casted as 
      // EventData* pointer 
    
      EventData *evtdata = static_cast(pData);
      .....
    }

动态转换：

void DebugLog::OnMessage(Message *msg)
    {
        
        static DebugMsgData *debug;
        static XYZMsgData *xyz;
    
        if(debug = dynamic_cast(msg->pdata)){
        
            // debug message
        }
        else if(xyz = dynamic_cast(msg->pdata)){
        
            // xyz message
        }
        else/* if( ... )*/{
        
            // ...
        }
    }

const\_cast ：

// *Passwd declared as a const
    
    const unsigned char *Passwd
    
    
    // on some situation it require to remove its constness
    
    const_cast(Passwd)

reinterpret\_cast ：

typedef unsigned short uint16;
    
    // Read Bytes returns that 2 bytes got read. 
    
    bool ByteBuffer::ReadUInt16(uint16& val) {
        
      return ReadBytes(reinterpret_cast(&val), 2);
    }

`其他一些答案的理论很好，但仍然令人困惑，在阅读其他答案后看到这些示例确实使它们都有意义。没有这些例子，我仍然不确定，但是有了它们，我现在可以确定其他答案的含义。`

`关于 reinterpret_cast 的最后一次用法：这和使用 static_cast(&val) 不一样吗？`

`@LorenzoBelli 当然不是。你试过了吗？后者不是有效的 C++ 并且会阻止编译。 static_cast 仅适用于具有已定义转换、继承可见关系或到/来自 void * 的类型。对于其他一切，还有其他演员表。 reinterpret cast 到任何 char * 类型都允许读取任何对象的表示 - 这是该关键字有用的唯一情况之一，而不是实现/未定义行为的猖獗生成器。但这不被视为“正常”转换，因此（通常）非常保守的 static_cast 不允许这样做。`

`当您使用数据库等系统软件时，reinterpret_cast 非常常见。大多数情况下，您编写自己的页面管理器，它不知道存储在页面中的数据类型是什么，只返回一个 void 指针。它由更高的层次来重新解释演员表并将其推断为他们想要的任何东西。`

`第一个示例很危险，因为它假定调用者的行为良好（始终传递指向实际 EventData 对象的指针，仅此而已）。不幸的是，我认为没有任何实用的方法可以以任何有意义的方式对 void 指针进行类型检查。理想情况下，参数将是强类型的。只是一些观察；不是对答案的批评。`

## 答4: ##

> huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

如果您了解一点内部知识可能会有所帮助…

static\_cast

C++ 编译器已经知道如何在定标器类型（例如 float 到 int）之间进行转换。为他们使用 static\_cast。

当您要求编译器从类型 A 转换为 B 时，static\_cast 调用 B 的构造函数，将 A 作为参数传递。或者，A 可以有一个转换运算符（即 A::operator B()）。如果 B 没有这样的构造函数，或者 A 没有转换运算符，则会出现编译时错误。

如果 A 和 B 在继承层次结构（或 void）中，则从 A\* 转换为 B\* 始终成功，否则会出现编译错误。

问题：如果将基指针转换为派生指针，但如果实际对象不是真正的派生类型，则不会出错。您会得到错误的指针，并且很可能在运行时出现段错误。 A& 到 B& 也是如此。

问题：从 Derived 转换为 Base 或反之亦然创建新副本！对于来自 C\#/Java 的人来说，这可能是一个巨大的惊喜，因为结果基本上是从 Derived 创建的一个切掉的对象。

dynamic\_cast

dynamic\_cast 使用运行时类型信息来确定强制转换是否有效。例如，如果指针实际上不是派生类型，则 (Base\*) 到 (Derived\*) 可能会失败。

这意味着，与 static\_cast 相比，dynamic\_cast 非常昂贵！

对于 A\* 到 B\*，如果转换无效，则 dynamic\_cast 将返回 nullptr。

对于 A& 到 B&，如果转换无效，则 dynamic\_cast 将抛出 bad\_cast 异常。

与其他强制转换不同，存在运行时开销。

const\_cast

虽然 static\_cast 可以对 const 做非常量，但它不能反过来。 const\_cast 可以做这两种方式。

这很方便的一个例子是遍历像 set 这样的容器，它只返回它的元素作为 const 以确保你不会改变它的键。但是，如果您的意图是修改对象的非关键成员，那么应该没问题。您可以使用 const\_cast 删除 constness。

另一个例子是当你想实现 T& SomeClass::foo() 以及 const T& SomeClass::foo() const 时。为避免代码重复，您可以应用 const\_cast 从另一个函数返回一个函数的值。

reinterpret\_cast

这基本上说在这个内存位置获取这些字节并将其视为给定对象。

例如，您可以将 4 字节的 float 加载到 4 字节的 int 中，以查看 float 中的位是什么样子。

显然，如果数据类型不正确，您可能会遇到段错误。

此演员表没有运行时开销。

`我添加了转换运算符信息，但还有一些其他的东西也应该修复，我觉得更新太多不太舒服。项目是： 1. If you cast base pointer to derived pointer but if actual object is not really derived type then you don't get error. You get bad pointer and segfault at runtime. 如果幸运的话，您会得到 UB，这可能会导致运行时出现段错误。 2. 动态铸件也可用于交叉铸件。 3. 常量转换在某些情况下会导致 UB。使用 mutable 可能是实现逻辑常量的更好选择。`

`@Adrian您在所有方面都是正确的。答案是为或多或少的初学者编写的，我不想让 mutable 带来的所有其他复杂情况、交叉施法等让他们不知所措。`

`@Shital Shah “从 Derived 转换为 Base 或反之会创建新副本！对于来自 C#/Java 的人来说，这可能是一个巨大的惊喜，因为结果基本上是从 Derived 创建的切掉的对象。”您能否展示一个简单的示例代码以使其更易于理解？谢谢。`

`那么 std::bit_cast 呢？`

## 答5: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

this 是否回答了您的问题？

我从未使用过 reinterpret\_cast，并且想知道遇到需要它的案例是否不是糟糕的设计。在我处理 dynamic\_cast 的代码库中被大量使用。与 static\_cast 的区别在于，dynamic\_cast 执行运行时检查，这可能（更安全）或可能不是（更多开销）是您想要的（请参阅 msdn）。

`我将 reintrepret_cast 用于一个目的——从双精度中获取位（与我的平台上的 long long 大小相同）。`

`例如，处理 COM 对象时需要 reinterpret_cast。 CoCreateInstance() 具有 void** 类型的输出参数（最后一个参数），您将在其中传递声明为例如“INetFwPolicy2* pNetFwPolicy2”的指针。为此，您需要编写类似 reinterpret_cast(&pNetFwPolicy2) 的内容。`

`也许有不同的方法，但我使用 reinterpret_cast 从数组中提取数据片段。例如，如果我有一个 char*，其中包含一个充满打包二进制数据的大缓冲区，我需要通过该缓冲区并获取不同类型的单个原语。像这样的东西：template unsigned int readValFromAddress(char* addr, ValType& val) { /*On platforms other than x86(_64) this could do unaligned reads, which could be bad*/ val = (*(reinterpret_cast(addr))); return sizeof(ValType); }`

`我从未使用过 reinterpret_cast，它的用途并不多。`

`就我个人而言，我只见过 reinterpret_cast 出于一个原因。我已经看到存储到数据库中的“blob”数据类型的原始对象数据，然后当从数据库中检索数据时，reinterpret_cast 用于将此原始数据转换为对象。`

## 答6: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

除了到目前为止的其他答案之外，这里还有一个不明显的例子，其中 static\_cast 不够，因此需要 reinterpret\_cast。假设有一个函数在输出参数中返回指向不同类（不共享公共基类）对象的指针。这种函数的一个真实示例是 CoCreateInstance()（参见最后一个参数，实际上是 void\*\*）。假设您从该函数请求特定类的对象，因此您事先知道指针的类型（您经常为 COM 对象执行此操作）。在这种情况下，您不能使用 static\_cast 将指向您的指针的指针转换为 void\*\*：您需要 reinterpret\_cast<void\*\*>(&yourPointer)。

在代码中：

#include 
    #include 
    .....
    INetFwPolicy2* pNetFwPolicy2 = nullptr;
    HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
        CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
        //static_cast(&pNetFwPolicy2) would give a compile error
        reinterpret_cast(&pNetFwPolicy2) );

但是，static\_cast 适用于简单指针（不是指向指针的指针），因此可以通过以下方式重写上述代码以避免 reinterpret\_cast（以额外变量为代价）：

#include 
    #include 
    .....
    INetFwPolicy2* pNetFwPolicy2 = nullptr;
    void* tmp = nullptr;
    HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
        CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
        &tmp );
    pNetFwPolicy2 = static_cast(tmp);

`它不会像 &static_cast(pNetFwPolicy2) 而不是 static_cast(&pNetFwPolicy2) 那样工作吗？`

## 答7: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

static\_cast vs dynamic\_cast vs reinterpret\_cast 内部视图在向下/向上变化

在这个答案中，我想在一个具体的向上/向下转换示例中比较这三种机制，并分析底层指针/内存/程序集发生了什么，以具体了解它们的比较方式。

我相信这将对这些演员的不同之处提供一个很好的直觉：

static\_cast：在运行时进行一个地址偏移（运行时影响低）并且不安全检查向下转换是否正确。

dyanamic\_cast：在运行时执行与 static\_cast 相同的地址偏移，但也会使用 RTTI 进行昂贵的安全检查，以确保向下转换是正确的。此安全检查允许您通过检查指示无效向下转换的 nullptr 返回来查询基类指针是否在运行时属于给定类型。因此，如果您的代码无法检查该 nullptr 并采取有效的非中止操作，您应该只使用 static\_cast 而不是动态转换。如果中止是您的代码可以采取的唯一操作，那么您可能只想在调试版本中启用 dynamic\_cast (-NDEBUG)，否则使用 static\_cast，例如，如此处所做的，以免减慢您的快速运行。

reinterpret\_cast: 在运行时什么都不做，甚至地址偏移也不做。指针必须准确地指向正确的类型，甚至基类都不起作用。除非涉及原始字节流，否则您通常不希望这样做。

考虑以下代码示例：

主文件

#include 
    
    struct B1 {
        
        B1(int int_in_b1) : int_in_b1(int_in_b1) {
        }
        virtual ~B1() {
        }
        void f0() {
        }
        virtual int f1() {
         return 1; }
        int int_in_b1;
    };
    
    struct B2 {
        
        B2(int int_in_b2) : int_in_b2(int_in_b2) {
        }
        virtual ~B2() {
        }
        virtual int f2() {
         return 2; }
        int int_in_b2;
    };
    
    struct D : public B1, public B2 {
        
        D(int int_in_b1, int int_in_b2, int int_in_d)
            : B1(int_in_b1), B2(int_in_b2), int_in_d(int_in_d) {
        }
        void d() {
        }
        int f2() {
         return 3; }
        int int_in_d;
    };
    
    int main() {
        
        B2 *b2s[2];
        B2 b2{
        11};
        D *dp;
        D d{
        1, 2, 3};
    
        // The memory layout must support the virtual method call use case.
        b2s[0] = &b2;
        // An upcast is an implicit static_cast<>().
        b2s[1] = &d;
        std::cout << "&d           " << &d           << std::endl;
        std::cout << "b2s[0]       " << b2s[0]       << std::endl;
        std::cout << "b2s[1]       " << b2s[1]       << std::endl;
        std::cout << "b2s[0]->f2() " << b2s[0]->f2() << std::endl;
        std::cout << "b2s[1]->f2() " << b2s[1]->f2() << std::endl;
    
        // Now for some downcasts.
    
        // Cannot be done implicitly
        // error: invalid conversion from ‘B2*’ to ‘D*’ [-fpermissive]
        // dp = (b2s[0]);
    
        // Undefined behaviour to an unrelated memory address because this is a B2, not D.
        dp = static_cast(b2s[0]);
        std::cout << "static_cast(b2s[0])            " << dp           << std::endl;
        std::cout << "static_cast(b2s[0])->int_in_d  " << dp->int_in_d << std::endl;
    
        // OK
        dp = static_cast(b2s[1]);
        std::cout << "static_cast(b2s[1])            " << dp           << std::endl;
        std::cout << "static_cast(b2s[1])->int_in_d  " << dp->int_in_d << std::endl;
    
        // Segfault because dp is nullptr.
        dp = dynamic_cast(b2s[0]);
        std::cout << "dynamic_cast(b2s[0])           " << dp           << std::endl;
        //std::cout << "dynamic_cast(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
    
        // OK
        dp = dynamic_cast(b2s[1]);
        std::cout << "dynamic_cast(b2s[1])           " << dp           << std::endl;
        std::cout << "dynamic_cast(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
    
        // Undefined behaviour to an unrelated memory address because this
        // did not calculate the offset to get from B2* to D*.
        dp = reinterpret_cast(b2s[1]);
        std::cout << "reinterpret_cast(b2s[1])           " << dp           << std::endl;
        std::cout << "reinterpret_cast(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
    }

编译、运行和反汇编：

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
    setarch `uname -m` -R ./main.out
    gdb -batch -ex "disassemble/rs main" main.out

其中 setarch 是 used to disable ASLR，以便更容易比较运行。

可能的输出：

&d           0x7fffffffc930
    b2s[0]       0x7fffffffc920
    b2s[1]       0x7fffffffc940
    b2s[0]->f2() 2
    b2s[1]->f2() 3
    static_cast(b2s[0])            0x7fffffffc910
    static_cast(b2s[0])->int_in_d  1
    static_cast(b2s[1])            0x7fffffffc930
    static_cast(b2s[1])->int_in_d  3
    dynamic_cast(b2s[0])           0
    dynamic_cast(b2s[1])           0x7fffffffc930
    dynamic_cast(b2s[1])->int_in_d 3
    reinterpret_cast(b2s[1])           0x7fffffffc940
    reinterpret_cast(b2s[1])->int_in_d 32767

现在，如https://en.wikipedia.org/wiki/Virtual\_method\_table所述，为了有效地支持虚方法调用，假设 B1 的内存数据结构为：

B1:
      +0: pointer to virtual method table of B1
      +4: value of int_in_b1

B2 的形式为：

B2:
      +0: pointer to virtual method table of B2
      +4: value of int_in_b2

那么 D 的内存数据结构必须类似于：

D:
      +0: pointer to virtual method table of D (for B1)
      +4: value of int_in_b1
      +8: pointer to virtual method table of D (for B2)
     +12: value of int_in_b2
     +16: value of int_in_d

关键事实是D的内存数据结构内部包含与B1和B2相同的内存结构，即：

\+0 看起来与 B1 完全一样，其中 D 的 B1 vtable 后跟 int\_in\_b1

\+8 看起来与 B2 完全一样，其中 D 的 B2 vtable 后跟 int\_in\_b2

因此，我们得出关键结论：

向上转换或向下转换只需将指针值移动编译时已知的值

这样，当 D 被传递到基本类型数组时，类型转换实际上会计算该偏移量并指向内存中看起来与有效 B2 完全相同的东西，除了这个具有 D 的 vtable 而不是B2，因此所有虚拟调用都是透明的。

例如：

b2s[1] = &d;

只需要获取d + 8的地址就可以到达对应的类B2数据结构。

现在，我们终于可以回到类型转换和具体示例的分析上了。

从标准输出输出我们看到：

&d           0x7fffffffc930
    b2s[1]       0x7fffffffc940

因此，在那里完成的隐式 static\_cast 确实正确计算了从 0x7fffffffc930 处的完整 D 数据结构到 B2 的偏移量，例如 0x7fffffffc940 处的偏移量。我们还推断，位于 0x7fffffffc930 和 0x7fffffffc940 之间的可能是 B1 数据和 vtable。

然后，在 downcast 部分，现在很容易理解无效部分如何失败以及为什么：

static\_cast(b2s\[0\]) 0x7fffffffc910: 编译器刚刚在编译时上升 0x10 字节尝试从 B2 转到包含 D 但因为 b2s\[0\] 不是 D，它现在指向一个未定义的内存区域。反汇编为：49 dp = static\_cast(b2s\[0\]); 0x0000000000000fc8 <+414>: 48 8b 45 d0 mov -0x30(%rbp),%rax 0x0000000000000fcc <+418>: 48 85 c0 测试%rax,%rax 0x0000000000000fcf <+421>: 74 0+xfdb 0x0000000000000fd1 <+423>: 48 8b 45 d0 mov -0x30(%rbp),%rax 0x0000000000000fd5 <+427>: 48 83 e8 10 子 $0x10,%rax 0x00000030000000fdjmp9 <+ ()+438> 0x0000000000000fdb <+433>: b8 00 00 00 00 mov $0x0,%eax 0x0000000000000fe0 <+438>: 48 89 45 98 mov %rax,-0x68(%rbp) 所以我们看到 GCC 确实：检查如果指针为NULL，如果是则返回NULL，否则，减去0x10到达不存在的D

检查指针是否为NULL，如果是则返回NULL

否则，减去 0x10 得到不存在的 D

dynamic\_cast(b2s\[0\]) 0：C++实际上发现强制转换无效并返回nullptr！这不可能在编译时完成，我们将通过反汇编确认： 59 dp = dynamic\_cast(b2s\[0\]); 0x00000000000010ec <+706>: 48 8b 45 d0 mov -0x30(%rbp),%rax 0x00000000000010f0 <+710>: 48 85 c0 测试%rax,%rax 0x00000000000010f3 <+713>11112<+713>: d je 11() 744> 0x0000000000000010F5 <+715>：B9 10 00 00 00 00 00 00 00 00 x10，％ecx 0x00000000000000001010110fa <+720>：48 8d 15 f7 0b 20 00 lea 0x200bf7（％RIP），％RIP），％RDX＃0x201CF8 <+700000000000000000000000000000000000000000000000个>: 48 8d 35 28 0c 20 00 lea 0x200c28(%rip),%rsi \# 0x201d30 <*ZTI2B2> 0x0000000000001108 <+734>: 48 89 c7 mov %rax,%rdi 0x000000000000110b <+ff>7000110b <+7 0xcd0 <*\_ dynamic\_cast@plt> 0x0000000000001110 <+742>：EB 05 JMP 0x1117 0x000000000000001112 <+7444>：B8 00 00 00 00 00 00 00 00 00 00 00 00 00 x 0x0，％eax 0x0，eax0x0000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111往mov %rax,-0x68(%rbp) 首先进行 NULL 检查，如果输入为 NULL，则返回 NULL。否则，它会在 RDX、RSI 和 RDI 中设置一些参数并调用 \_\_dynamic\_cast。我现在没有耐心对此进行进一步分析，但正如其他人所说，唯一可行的方法是让 \_\_dynamic\_cast 访问一些表示类层次结构的额外 RTTI 内存数据结构。因此，它必须从该表的 B2 条目开始，然后遍历该类层次结构，直到找到来自 b2s\[0\] 的 D 类型转换的 vtable。这就是为什么动态转换可能很昂贵的原因！这是一个示例，其中在复杂项目中将 dynamic\_cast 转换为 static\_cast 的单行补丁将运行时间减少了 33%！。

reinterpret\_cast(b2s\[1\]) 0x7fffffffc940 这个只是盲目相信我们：我们说地址b2s\[1\]有一个D，编译器不做偏移量计算。但这是错误的，因为D实际上在0x7fffffffc930，0x7fffffffc940是D内部的类似B2的结构！所以垃圾被访问了。我们可以从可怕的 -O0 程序集中确认这一点，它只是移动了值： 70 dp = reinterpret\_cast(b2s\[1\]); 0x00000000000011fa <+976>: 48 8b 45 d8 mov -0x28(%rbp),%rax 0x00000000000011fe <+980>: 48 89 45 98 mov %rax,-0x68(%rbp)