C++ 运行时类别识别

运行时动态类型的识别其实应该是多态方面的知识，这里我直接拿来单独成章。

 

 dynamic_cast和static_cast

 

1.static_cast用法以下：

static_cast < Type-id > ( expression )

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要可用于如下几种状况：

（1）用于类层次结构中基类和派生类之间指针或引用的转换。进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成派生类表示）时，因为没有动态类型检查，因此是不安全的。
（2）用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
（3）把空指针转换成目标类型的空指针(不安全！！)。
（4）把任何类型的表达式转换成void类型。

class Base { };
class Derived:public Base {};
int main()
{
    Base b;
    Derived* pD = &b; //error C2440: “初始化”: 没法从“Base *”转换为“Derived *”
    pD = static_cast<Derived*> (&b);
    return 0;
}

在上面代码中pD做为一派生类指针，将它指向基类是错误的（但反过来是能够的）。

能够用static_cast将基类指针强制转换为派生类指针，这样即可以将pD指向基类对象。

但像上面这样使用static_cast进行向上映射时，是至关危险的，可能会形成没法跟踪的运行期错误。

C++提供了dynamic_cast操做符，能够在运行期间检测类型转换是否安全。dynamic_cast和static_cast有一样的语法：
     

  dynamic_cast < Type-id > ( expression )

 

The dynamic_cast operator in C++ is used for downcasting a reference or pointer to a more specific type in the class hierarchy. Unlike the static_cast, the target of the dynamic_cast must be a pointer or reference to class.


Type-id必须是一个类的的指针或引用，也能够是 void *，参数expression必须是一个能获得一个指针或者引用的表达式。

同时，dynamic_cast仅对多态类型有效，也就是说使用dynamic_cast时要求基类中要有虚函数，不然会有编译错误；

而static_cast则没有这个限制。另外dynamic_cast要求转型的目的类型必须是指针或者引用。这是因为运行时类型检查须要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

 

例：

class Base
{
public:
    void fun( ) {};
};
class Derived:public Base { };
int main( )
{
    Base b;
    Derived d;
    Base *pb = &b;
    Derived *pd1 = static_cast<Derived *> (pb);
    Derived *pd2 = dynamic_cast<Derived *>(pb);  // error C2683: “dynamic_cast”:“Base”不是多态类型
    return 0;
}

若将fun()函数声明为虚函数，则不会有上面的错误。

若是pb实际指向一个 Derived类型的对象，pd1和pd2是同样的，而且这两个指针执行Derived类型的任何操做都是安全的；若是pb实际指向的是一个Base类型的对象，那么pd1将是一个指向该对象的指针，对它进行Derived类型的操做将是不安全的，而pd2将会获得一个空指针（即0，由于dynamic_cast失败）!

 

例：

 

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void fun1()
    {
        cout << "Base::fun1()" << endl;
    }
    virtual ~Base() { }
};
class Derived1: public Base
{
public:
    virtual void fun1()
    {
        cout << "Derived1::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Derived1::fun2()" << endl;
    }
};
class Derived2: public Derived1
{
public:
    virtual void fun1()
    {
        cout << "Derived2::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Derived2::fun2()" << endl;
    }
};
void fun(Base *b)
{
    b->fun1();
    //尝试将b转换为Derived1指针
    Derived1 *d = dynamic_cast<Derived1 *>(b);
    //判断转换是否成功
    if (d != 0)
        d->fun2();
}
int main()
{
    Base b;
    fun(&b);
    Derived1 d1;
    fun(&d1);
    Derived2 d2;
    fun(&d2);
    return 0;
}

 

运行结果：

Base::fun1()
Derived1::fun1()
Derived1::fun2()
Derived2::fun1()
Derived2::fun2()

 

 

typeid 获取运行时类型信息

 

typeid语法形式：
typeid ( 表达式 )
typeid ( 类型说明符 )

typeid功能
得到表达式或类型说明符的类型信息，表达式有多态类型时，会被求值，并获得动态类型信息；不然，表达式不被求值，只能获得静态的类型信息。

类型信息用type_info对象表示，type_info是typeinfo头文件中声明的类；

typeid的结果是type_info类型的常引用；
能够用type_info的重载的“==”、“!=”操做符比较两类型的异同；
type_info的name成员函数返回类型名称，类型为const char *。

#include <iostream>
#include <typeinfo>
using namespace std;
class Base
{
public:
    virtual ~Base() { }
};
class Derived: public Base { };
void fun(Base *b)
{
    const type_info &info1 = typeid(b);
    const type_info &info2 = typeid(*b);
    cout<<"typeid(b): "<<info1.name ()<<endl;
    cout<<"typeid(*b): "<<info2.name ()<<endl;
    if(info2 == typeid(Base))
        cout<<"A base class!"<<endl;
    else
        cout<<"A Derived class!"<<endl;
    cout<<endl;
}
int main()
{
    Base b;
    fun(&b);
    Derived d;
    fun(&d);
    return 0;
}

运行结果：

typeid(b): P4Basetypeid(*b): 4BaseA base class!typeid(b): P4Basetypeid(*b): 7DerivedA Derived class!