c++RTTI

介绍

1.RTTI是运行阶段类型识别的简称。这是新添加到c++中的特性之一。

2.用途：假设有一个类层次结构，其中的类都是从同一个基类派生而来的，则可以让基类指针指向其中任何一个类的对象。这样就可以调用这些函数：处理信息后，选择哪个类，并创建这种类型的对象，然后返回它的地址，而该地址可以被赋给基类指针。如何知道指针指向的是那种对象呢？

在了解答案前，应考虑为何要知道类型。可能希望调用类方法的正确版本，在这种情况下，只要该函数是类层次结构中所有成员都拥有的虚函数，则并不希望需要知道对象的类型。但派生对象可能包含不是继承而来的方法，在这种情况下，只有某些类型的对象可以使用该方法，也可能是出于调式目的，想知道生成对象的类型。RTTI提供解决方案。

RTTI的工作原理

c++有3个支持RTTI的元素

1. 如果可能的话，dynameic_cast运算符将使用一个指向基类的指针来生成一个指向派生类的指针；否则，该运算符返回0-空指针。
2. typeid运算符返回一个指出对象的类型的值。
3. type_info结构存储了有关特定类型的信息。

只能将RTTI用于包含虚函数的类层次结构，原因在于只有对于这种类层次结构，才应该将派生对象的地址赋给基类指针。

注：RTTI只适用于包含虚函数的类。

dynamic_cast运算符

dynamic_cast运算符是最常用的RTTI组件，作用：安全地将对象的地址赋给特定类型的指针。例：

class Grand{//虚函数}；
class Superb:public Grand{...};
class Magnificent:public Superb{...};

假设有下面的指针：

Grand * pg =new Grand;
Grand * ps = new Superb;
Grand * pm = new Magnificent;

最后，对于下面的类型转换：

Magnificent * p1 = (Magnificent *) pm;//安全;将Magnificent类型的指针指向类型为Magnificent的对象
Magnificent *  p2=(Magnificent *) pg;//不安全;将基数对象Grand的地址赋给派生类Magnificent指针。例如：Magnificent中可能包含一些Grand对象没有的数据成员
Superb * p3= (Magnificent *) pm;//安全，将派生对象的地址赋给基类指针。即公有派生确保Magnificent对象同时也是Superb对象（直接基类）和一个Grand（间接基类）。

1. 只有指针类型与对象的类型（或对象的直接或间接基类的类型）相同的类型转换才一定是安全的。

2. 虚函数确保了将三种指针中的任何一种指向Magnificent对象时，都将调用Magnificent方法。

3. 相比指针指向得是那种类型的对象，类型转换是否安全更通用，也更有用。

4. 通常想知道类型的原因在于：知道类型后，就知道调用特定的方法是否安全，要调用方法，类型并不一定要完全匹配，而是定义了方法的虚拟版本的基类类型。
   例：
   dynamic_cast的语法：

Superb * pm = dynamic_cast<Superb *>(pg);

指针pg的类型是否可被安全地转换为Superb*?如果可以，运算符将返回对象的地址，否则返回一个空指针。

注：如果指向的对象（*pt）的类型为Type或者是从Type直接或间接派生而来的类型，则下面的表达式将指针pt转换为Type类型的指针：

dynamic_cast<Type *>(pt)

否则，结果为0，即空指针。

例：

#include <iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
class Grand
{
private:
    int hold;
public:
    Grand(int h=0):hold(h){}
    virtual void Speak()const{cout<<"I am a grand class!\n";}
    virtual int Value()const{return hold;}
};

class Superb:public Grand
{
public:
    Superb(int h=0):Grand(h){}
 void Speak()const{cout<<"I am a superb class!!\n";}
    virtual void Say()const
    {
      { cout<<"I hold the superb value of"<<Value()<<"!\n";}

    }
};


class Magnificent:public Superb
{
private:
    char ch;
public:
    Magnificent(int h=0,char c='A'):Superb(h),ch(c){}
    void Speak()const{cout<<"I am a magnificent class!!!\n";}
    void Say()const{cout<<"I hold the character"<<ch<<
                           "and the integer"<<Value()<<"!\n";}
};


Grand * GetOne();

int main()
{
    srand(time(0));
    Grand * pg;
    Superb * ps;
    for(int i=0;i<5;i++)
    {
        pg=GetOne();
        pg->Speak();
        if(ps=dynamic_cast<Superb *>(pg))
            ps->Say();//转换成功，ps的值为true；失败，pg指向一个Grand对象，ps的值将为false.
    }
    return 0;
}

Grand *GetOne()
{
    Grand * p;
    switch(rand()%3)
    {
    case 0:p=new Grand(rand()%100);
        break;
    case 1:p=new Superb(rand()%100);
        break;
    case 2:p=new Magnificent(rand()%100,
                             'A'+rand()%26);
        break;
    }
    return p;
}

注：程序说明重要一点，应尽可能使用虚函数，而只在必要时使用RTTI。

也可以将dynamic_cast用于引用，语法有点不同：没有与空指针对应的引用值，因此无法使用特殊的引用值来指示错误。当请求不正确时，dynamic_cast将引发类型为bad_cast的异常，这种异常是从exception类派生而来，它是在头文件typeinfo中定义的。因此下面的rg是对Grand对象的引用：

#include<typeinfo>
...
try{
Superb & rs = dynamic_cast<Superb &>(rg);
...
}
catch(bad_cast &){
...
};

typeid运算符和type_info类

typeid运算符使得能够确定两个对象是否为同种类型。它与sizeof有些相像，可以接受两种参数：

1. 类名；
2. 结果为对象的表达式；

typeid运算符返回一个对type_info对象的引用，其中，typed_info是在头文件：typeinfo中定义的一个类。
type_info类重载了==和！=运算符，用于对类型的比较。例：pg指向的是Magnificent对象。则下面的表达式结果为bool值true,否则false:

typeid(Magnificent)==typeid(*pg)

如果pg是空指针，程序将引发bad_typeid异常。该异常类型从exception类派生而来，是在头文件typeinfo中声明的。

#include<iostream>
#include<cstdlib>
#include<ctime>
#include<typeinfo>
using namespace std;
class Grand
{
private:
    int hold;
public:
    Grand(int h=0):hold(h){}
    virtual void Speak()const { cout << "I am a grand class!\n";}
    virtual int Value()const { return hold; }
};

class Superb :public Grand
{
public:
    Superb(int h=0):Grand(h){}
    void Speak()const { cout << "I am a magnificent class!!!\n"; }
    virtual void Say()const {
        cout << "I hold the superb value of" << Value() << "!\n";
    }
};

class Magnificent :public Superb
{
private:
    char ch;
public:
    Magnificent(int h = 0, char cv = 'A') :Superb(h), ch(cv) {}
    void Speak()const { cout << "I am a magnificent class!!!\n"; }
    void Say()const {
        cout << "I hold the character" << ch <<
            "and the integer" << Value() << "!\n";
    }
};

Grand* GetOne();
int main()
{
    srand(time(0));
    Grand* pg;
    Superb* ps;
    for (int i = 0; i < 5; i++)
    {
        pg = GetOne();
        cout << "Now processing type" << typeid(*pg).name() << ".\n";//name()函数返回一个随实现而异的字符串：通常类的名称
        pg->Speak();
        if (ps = dynamic_cast<Superb*>(pg))
            ps->Say();
        if (typeid(Magnificent) == typeid(*pg))
            cout << "Yes,you're really magnificent.\n";
    }
    return 0;
}

Grand * GetOne()
{
    Grand * p;
    switch (rand() % 3)
    {
    case 0:p = new Grand(rand() % 100);
        break;
    case 1:p = new Superb(rand() % 100);
        break;
    case 2:p = new Magnificent(rand() % 100, 'A' + rand() % 26);
        break;
    }
    return p;
}

注：每次运行输出都可能不同，因为它使用rand（）来选择类型。另外，调用name()时，有些编译器提供不同的输出。

误用RTTI的例子

c++界有人认为RTTI是多余的，是导致程序效率低下和糟糕编程方式的罪魁祸首。下面介绍应避免的编程方式。
例：

Grand * pg;
    Superb * ps;
    for(int i=0;i<5;i++)
    {
        pg=GetOne();
        pg->Speak();
        if(ps=dynamic_cast<Superb *>(pg))
            ps->Say();

通过放弃dynamic_cast和虚函数，而使用typeid，可以将上述代码重新编写：

Grand * pg;
Superb * ps;
Magnificent * pm;
for(int i=0;i<5;i++)
{
	pg=GetOne();
	if(typeid(Magnificent)==typeid(*pg))
	{
		pm=(Magnificent *)pg;
		pm=Speak();
		pm=Say();
		}
		else if(typeid(Superb)==typeid(*pg))
		{
			ps=(Superb *) pg;
			ps->Speak();
			ps->Say();
		}
		else
		pg->Speak();
		}

上面的代码比原来的更难看，更长，而且显示地指定各个类存在严重的缺陷。例：如果发现必须从Magnificent类派生一个Insufferable类，而后者需要重新定义Speak()和Say()。使用typeid来显示地测试每个类型时，必须修改for循环的代码，添加一个else if,但无需修改原来的版本。下面的语句适用于所有从Grand派生而来的类：
pg->Speak();
而下面得语句适用于所有从Superb派生而来的类：

if(ps=dynamic_cast<Superb *>(pg))
ps->Say();

注：如果发现在扩展的if else 语句系列中使用了typeid，则应考虑是否应该使用虚函数和dynamic_cast。