dynamic_cast和static_cast

百度百科
dynamic_cast将一个基类对象指针（或引用）cast到继承类指针，dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理
- 外文名: dynamic_cast
- 特点: 可以在执行期决定真正的类型
- 用途: 类层次间的上行转换和下行转换
- 性质: 运算符

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

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

classB
{
public:
    int m_iNum;
    virtual void foo();
};

classD:
publicB
{
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 将是一个空指针。

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

这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

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

classA
{
public:
    intm_iNum;
    virtual void f() {}
};
class B: public A
{
};
class D: public A
{
};
void foo()
{
    B *pb = newB;
    pb->m_iNum = 100;
    //D*pd1=static_cast<D*>(pb);//compile error
    D *pd2 = dynamic_cast<D *>(pb); //pd2isNULL
    delete pb;
}

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

运用实例

问题

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

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

实例

//TestCast.cpp:Definestheentrypointfortheconsoleapplication.
//
#include"stdafx.h"
#include<iostream>
using namespace std;
class Base
{
public:
    virtual voidf()
    {
        cout << "Base::f" << endl;
    }
    void f1()
    {
        cout << "Base::f1" << endl;
    }
private:
    double x;
    double y;
};
classDerived:
publicBase
{
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。
    /**/////Errorcode
    //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();
    /**/////errorcannotcompiler
    //Base1*pB2=static_cast<Base1*>(pD);
    //pB2->g();
    //当然对于pB不是真的指向Derived1，想要转化为Derived1或Base的兄弟类Base1，情况与Test1中的error情况相同。
}
int _tmain(int argc, _TCHAR *argv[])
{
    Test1();
    Test2();
    return 0 ;
}

dynamic_cast和static_cast

猜你喜欢