dynamic_cast

dynamic_cast < type-id > ( expression )

该运算符把 expression转换成type-id类型的对象。Type-id必须是类的 指针、类的引用或者 void*；

如果type-id是类 指针类型，那么 expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。

dynamic_cast 运算符可以在执行期决定真正的类型。如果downcast是安全的（也就说，如果基类 指针或者引用确实指向一个 派生类对象）这个运算符会传回适当转型过的指针。如果downcast不安全，这个运算符会传回空 指针（也就是说，基类指针或者引用没有指向一个 派生类对象）。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。

在类层次间进行上行转换时， dynamic_cast和 static_cast的效果是一样的；

在进行下行转换时， dynamic_cast具有类型检查的功能，比 static_cast更安全。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class B { public :     int m_iNum;     virtual void foo(); }; class D: public B { public :     char *m_szName[100]; }; void func(B *pb) {     D *pd1 = static_cast <D *>(pb);     D *pd2 = dynamic_cast <D *>(pb); }

在上面的 代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个 指针执行D类型的任何操作都是安全的；

但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的 指针，对它进行D类型的操作将是不安全的（如访问m_szName），

而pd2将是一个空 指针。

2注意事项

B要有 虚函数，否则会编译出错； static_cast则没有这个限制。

B中需要检测有 虚函数的原因：类中存在虚函数，就说明它有想要让 基类 指针或引用指向 派生类对象的情况，此时转换才有意义。

这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的 虚函数表（关于 虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，

没有定义 虚函数的类是没有 虚函数表的。

另外， dynamic_cast还支持交叉转换（cross cast）。如下代码所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class A { public :     int m_iNum;     virtual void f(){} }; class B: public A { }; class D: public A { }; void foo() {     B *pb = new B;     pb->m_iNum = 100;     D *pd1 = static_cast <D *>(pb); //compile error     D *pd2 = dynamic_cast <D *>(pb); //pd2 is NULL     delete pb; }

在函数foo中，使用 static_cast进行转换是不被允许的，将在编译时出错，而使用 dynamic_cast的转换则是允许的，结果是空指针。

3运用实例

问题

1）什么时候应必须使用 dynamic_cast

2）什么时候 dynamic_cast可以使用 static_cast代替

实例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// TestCast.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; class Base { public :     virtual void f() { cout << "Base::f" << endl; }     void f1(){cout << "Base::f1" << endl;} private :     double x;     double y; }; class Derived : public Base { public :     virtual void f(){cout << "Derived::f" << endl; }     virtual void k(){cout << "Derived::k" << endl; } private :     double z; }; class Base1 { public :     virtual void g(){ cout << "Base1::g" << endl;}     void g1(){cout << "Base1::g1" << endl;} }; class Derived1 : public Base, public Base1 { public :     virtual void f(){ cout << "Derived1::f" << endl;}     virtual void h(){ cout << "Derived1::h" << endl;} }; void Test1() {     // 对于单继承，     // 如果pD真的指向Derived，用dynamic_cast和static_cast效果相同     Base *pD = new Derived;     Derived *pD1 = dynamic_cast <Derived*>(pD);     pD1->f();     pD1->k();     pD1->f1();     Derived *pD2 = static_cast <Derived*>(pD);     pD2->f();     pD2->k();     pD2->f1();     // 但是如果pB不是真的指向Derived，则用dynamic_cast则返回NULL，能够更早的禁止error的发生，     // 如果用static_cast虽然返回的不为NULL，但是运行时可能抛出exception。     /**/ //// Error code     //Base *pB = new Base();     //Derived *pD3 = static_cast<Derived*>(pB);     //pD3->f();     //pD3->k();     //pD3->f1();     //Derived *pD4 = dynamic_cast<Derived*>(pB);     //pD4->f();     //pD4->k();     //pD4->f1(); } void Test2() {     // 对于多重继承，     // 如果pD真的指向的是Derived1，使用dynamic_cast和static_cast都可以转化为Derived1，     // 但是如果要转化为Base的兄弟类Base1，必须使用dynamic_cast，使用static_cast不能编译。     Base *pD = new Derived1;     Derived1 *pD1 = dynamic_cast <Derived1*>(pD);     pD1->f();     pD1->h();     pD1->f1();     Base1 *pB1 = dynamic_cast <Base1*>(pD);     pB1->g();     Derived1 *pD2 = static_cast <Derived1*>(pD);     pD2->f();     pD1->h();     pD2->f1();     /**/ //// error can not compiler     //Base1 *pB2 = static_cast<Base1*>(pD);     //pB2->g();     // 当然对于pB不是真的指向Derived1，想要转化为Derived1或Base的兄弟类Base1，情况与Test1中的erro    r情况相同。 } int _tmain( int argc, _TCHAR* argv[]) {     Test1();     Test2();     return 0; }