C++新式转型之dynamic_cast

港控/mmm° 2022-06-13 14:43 183阅读 0赞

dynamic\_cast的文章看了很多，大多是说，“可以这样做，不可以这样做”，今天花了半天时间，仔细学了一下，收获颇丰。整理了一下，比较乱，很多东西依然模棱两可，有机会看了《深入理解C++对象模型》之后再好好补充。

## dynamic\_cast ##

主要用来执行“安全向下转型”，也就是用来决定某对象是否归属继承体系中的某个类型。

`dynamic_cast`是用来检查两者是否有继承关系。因此该运算符实际上只接受基于类对象的指针和引用的类转换。

来看cppreference上面的说法：

dynamic_cast < new_type > ( expression )

> ***1) If the type of expression is exactly new\_type or a less cv-qualified version of new\_type, the result is the value of expression, with type new\_type. (In other words, dynamic\_cast can be used to add constness. An implicit cast and static\_cast can perform this conversion as well.)***

class Fuck
    {
    public:
        int a;
        Fuck():a(10){}
        ~Fuck(){}
    };
    
    int main() {
        Fuck f;
        const Fuck *pb = dynamic_cast< const Fuck *>(&f);
        //const Fuck b = dynamic_cast< const Fuck >(f);//error:必须是指向完整类类型指针或者void*
        const Fuck cf;
        //Fuck *pc=dynamic_cast<Fuck*>(&cf);//error:这件事应该交给const_cast
        cout << pb->a << endl;//输出10
        system("pause");
        }

类型一致没什么好说的，这跟static\_cast行为一致。并且可以对less-cv的type做const转型，用原文的话来说：***dynamic\_cast can be used to add constness***

> ***2) If the value of expression is the null pointer value, the result is the null pointer value of type new\_type.***

空指针的转型将得到新类型的空指针。

> ***3) If new\_type is a pointer or reference to Base, and the type of expression is a pointer or reference to Derived, where Base is a unique, accessible base class of Derived, the result is a pointer or reference to the Base class subobject within the Derived object pointed or identified by expression. (Note: an implicit cast and static\_cast can perform this conversion as well.)***

子类对象向基类的转型，即用基类指针指向子类对象，这种转型操作用static\_cast也可以进行。这是隐式的转换。

class Base
    {
    public:
        Base(){}
        virtual ~Base(){}
        virtual void print(){ cout << "base" << endl; }
    };
    class Derived :public Base
    {
    public:
        Derived(){}
        ~Derived(){}
        void print(){ cout << "Derived" << endl; }
    };
    
    int main() {
        Derived d;
        Base * pb1 = dynamic_cast<Base*>(&d);
        Base * pb2 = static_cast<Base*>(&d);
        //pb1指向Base subobject of Derived
        pb1->print();//derived
        pb2->print();//derived
        system("pause");
    }

此种类型的转换称之为“向上转换”。

> ***4) If expression is a pointer or reference to a polymorphic type, and new\_type is a pointer to void, the result is a pointer to the most derived object pointed or referenced by expression.***

如果 `new-type` 为 `void*`，则做运行时进行检查确定 expression的实际类型。 结果是指向 by expression 的完整的对象的指针。 例如：

#include <string>
    #include <iostream>
    using namespace std;
    class A { 
    public:
        virtual void f(){}
    };
    class B :public A{ 
    public:
        virtual void f(){}
    };
    
    int main()
    {
        A* pa = new A;
        B* pb = new B;
        void* pv = dynamic_cast<void*>(pa);
        // pv now points to an object of type A  
        pv = dynamic_cast<void*>(pb);
        // pv now points to an object of type B  
        system("pause");
        return 0;
    }

通过单步调试可以看到指针所指向的内容。

--------------------

> ***5) If expression is a pointer or reference to a polymorphic type Base, and new\_type is a pointer or reference to the type Derived a run-time check is performed:***
> 
> ***a) The most derived object pointed/identified by expression is examined. If, in that object, expression points/refers to a public base of Derived, and if only one subobject of Derived type is derived from the subobject pointed/identified by expression, then the result of the cast points/refers to that Derived subobject. (This is known as a “downcast”.)***
> 
> ***b) Otherwise, if expression points/refers to a public base of the most derived object, and, simultaneously, the most derived object has an unambiguous public base class of type Derived, the result of the cast points/refers to that Derived (This is known as a “sidecast”.)***
> 
> ***c) Otherwise, the runtime check fails. If the dynamic\_cast is used on pointers, the null pointer value of type new\_type is returned. If it was used on references, the exception std::bad\_cast is thrown.***

这一条相对复杂，其实是`dynamic_cast`的核心，总结起来就是三点：  
1.downcast  
2.sidecast  
3.非法cast(指针返回null，引用抛出异常)

先看一个示例，这是一个菱形继承：

class A { virtual void f(){} };
    class B :  public A { virtual void f(){} };
    class C :  public A { };
    class D { virtual void f(){} };
    class E : public B, public C { virtual void f(){} };
    
    
    int main()
    {
        E e;
        B &b = e;//upcast
        E & re = dynamic_cast<E&>(b);//downcast
        C&c = dynamic_cast<C&>(b);//sidecast
        try
        {
            D&d = dynamic_cast<D&>(e);
        }
        catch (std::bad_cast& bc)
        {
       //异常将被捕获
            std::cerr << "bad_cast caught: " << bc.what() << '\n';
        }
    
        system("pause");
        return 0;
    }

首先upcast是一种向上转型的方式，这是隐式转换，即使使用传统C风格或者static\_cast也可以实现，也容易理解，我们有一个派生类对象，用基类的指针或引用指向它，我们说这个基类的指针或者引用将指向subobject。  
关于什么是subobject，简单的示例：

class Foo { int i; };
    class Bar : public Foo { int j; };

\+-Bar——————-+  
|　+-Foo—–+　　　　|  
|　|　　int i 　|　　int j; |  
|　+———+　　　　 |  
\+———————–+

Bar b;
    Bar* pBar = &b;
    Foo* pFoo = &b;//pFoo指向b的一个subobject

\+-Bar——————-+  
|　　+-Foo—–+　 　　|  
|　　|　　int i　|　int j;　|  
|　　+———+　　　　|  
\+–^——————–+  
^　|pFoo  
|pBar

> ***Objects can contain other objects, called subobjects. A subobject can be a member subobject, a base class subobject, or an array element. An object that is not a subobject of any other object is called a complete object.***

这跟对象模型有关，有机会一定要看看《深入理解C++对象模型》这本书。

下面再看看downcast和sidecast。

### **downcast** ###

英文很晦涩啊，理解起来不难，看“方向”就行，down是向下转型，side是向旁边转型。

dynamic_cast<new_type>(expression);

通过expression可以找到该指针指向的在继承层次中，最下面的对象，expression指向继承类的一个共有基类对象，且该继承类对象的subobject继承于expression所指向基类的subobject。

以上面的例子为例，首先，继承层次中最下面的对象为`E e;`，expression是一个B类型的引用，E的subobject就是B的对象本身。从基类指针向派生类指针的转型，称之为downcast。

### **sidecast** ###

通过expression可以找到该指针指向的在类层次中，最下面的对象，expression指向该对象的共有基类对象，`new_type`是这个最下面对象的一个明确的共有基类类型，此时将得到一个指向new\_type的指针，称之为sidecast。从上面的例子来看，好像指针从A偏向了B。

最后一种情况就是转型失败，指针将返回NULL，reference将抛出异常。至于什么时候会转型失败，主要还是待转型的指针指向的类继承层次最下面的那个对象所包含了subobject了。。

## **参考** ##

[cppreference][]  
[stackoverflow][]

[cppreference]: http://en.cppreference.com/w/cpp/language/dynamic_cast
[stackoverflow]: https://stackoverflow.com/questions/18451683/c-disambiguation-subobject-and-subclass-object