c++ primer plus 第15章友，异常和其他 15.4RTTI

#c++ primer plus 第15章友，异常和其他 15.4RTTI
c++ primer plus 第15章友，异常和其他 15.4RTTI

---

15.4RTTI

RTTI是运行阶段类型识别(Runtime Type Identification)的简称。这是新添加到 C++中的特性之一,很多老式实现不支持。另一些实现可能包含开关 RTTI的编译器设置。RTTI旨在为程序在运行阶段确定对象的类型提供一种标准方式。很多类库已经为其类对象提供了实现这种功能的方式，但由于C++内部并不支持，因此各个厂商的机制通常互不兼容。创建一种 RTTI语言标准将使得未来的库能够彼此兼容。

15.4.1 RTTI的用途

假设有一个类层次结构，其中的类都是从同一个基类派生而来的，则可以让基类指针指向其中任何一个类的对象。这样便可以调用这样的函数:在处理一些信息后，选择一个类，并创建这种类型的对象，然后返回它的地址，而该地址可以被赋给基类指针。如何知道指针指向的是哪种对象呢?在回答这个问题之前，先考虑为何要知道类型。可能希望调用类方法的正确版本，在这种情况下，只要该函数是类层次结构中所有成员都拥有的虚函数，则并不真正需要知道对象的类型。但派生对象可能包含不是继承而来的方法，在这种情况下，只有某些类型的对象可以使用该方法。也可能是出于调试目的,想跟踪生成的对象的类型。对于后两种情况，RTTI提供解决方案。

15.4.2 RTTI的工作原理

C++有3个支持RTTI的元素。
如果可能的话，dynamic cast 运算符将使用一个指向基类的指针来生成一个指向派生类的指针;否则，该运算符返回0–空指针。
typeid 运算符返回一个指出对象的类型的值。type_info 结构存储了有关特定类型的信息。只能将 RTTI用于包含虚函数的类层次结构，原因在于只有对于这种类层次结构，才应该将派生对象的地址赋给基类指针。
警告:RTTI只适用于包含虚函数的类
下面详细介绍 RTTI的这3个元素。

1.dynamic cast运算符

dynamic_cast运算符是最常用的 RTTI组件，它不能回答“指针指向的是哪类对象”这样的问题，但能够回答“是否可以安全地将对象的地址赋给特定类型的指针”这样的问题。我们来看一看这意味着什么。假设有下面这样的类层次结构:

class Grand(//has virtual methods);
class Superb:public Grand(...);
class Magnificent:public Superb...);

接下来假设有下面的指针:

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

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

Magnificent *pl=(Magnificent*)pm;// #1
Magnificent*p2=(Magnificent*)pg;//#2
Superb*p3=(Magnificent*)pm;// #3

哪些是安全的?根据类声明，它们可能全都是安全的，但只有那些指针类型与对象的类型(或对象的直接或间接基类的类型)相同的类型转换才一定是安全的。例如，类型转换#1就是安全的，因为它将 Magificent 类型的指针指向类型为Magnificent 的对象。类型转换#2 就是不安全的，因为它将基数对象(Grand)的地址赋给派生类(Magnifcent)指针。因此，程序将期望基类对象有派生类的特征而通常这是不可能的。例如，Magnificent对象可能包含一些Grand 对象没有的数据成员。然而，类型转换#3是安全的，因为它将派生对象的地址赋给基类指针。即公有派生确保Magnificent 对象同时也是一个 Superb对象(直接基类)和一个Grand对象(间接基类)。因此，将它的地址赋给这3种类型的指针都是安全的。虚函数确保了将这3种指针中的任何一种指向Magnificent 对象时，都将调用Magnificent 方法。
注意，与问题“指针指向的是哪种类型的对象”相比，问题“类型转换是否安全”更通用，也更有用。通常想知道类型的原因在于:知道类型后，就可以知道调用特定的方法是否安全。要调用方法，类型并不一定要完全匹配，而可以是定义了方法的虚拟版本的基类类型。下面的例子说明了这一点。
然而，先来看一下 dynamic cast 的语法。该运算符的用法如下，其中pg指向一个对象:

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

这提出了这样的问题:指针pg的类型是否可被安全地转换为Superb*?如果可以，运算符将返回对象的地址，否则返回一个空指针。
注意:通常，如果指向的对象(*pt)的类型为Type 或者是从 Type 直接或间接派生而来的类型，则下面的表达式将指针 pt 转换为 Type 类型的指针:

dynamic cast<Type *>(pt)

否则，结果为0，即空指针。
程序清单 15.17演示了这种处理。首先，它定义了3个类,名称为Grand、Superb和 Magnificent。Grand类定义了一个虚函数 Speak()，而其他类都重新定义了该虚函数。Superb 类定义了一个虚函数 Say()，而Manificent 也重新定义了它(参见图 15.4)。程序定义了 GetOne()函数，该函数随机创建这3种类中某种类的对象，并对其进行初始化，然后将地址作为Grand*指针返回(GetOne()函数模拟用户做出决定)。循环将该指针赋给 Grand *变量 pg，然后使用pg调用 Speak()函数。因为这个函数是虚拟的，所以代码能够正确地调用指向的对象的 Speak()版本。

for(int i=0;i <5;i++)
{
pg = GetOne();
pg->Speak();
}

然而，不能用相同的方式(即使用指向Grand的指针)来调用Say()函数，因为Grand 类没有定义它。然而，可以使用 dynamic_cast 运算符来检查是否可将pg的类型安全地转换为 Superb 指针。如果对象的类型为 Superb或Magnifcent，则可以安全转换。在这两种情况下，都可以安全地调用 Say()函数:

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

赋值表达式的值是它左边的值,因此if条件的值为ps。如果类型转换成功,则ps的值为非零(true);如果类型转换失败，即pg指向的是一个Grand对象，ps的值将为0(false)。程序清单 15.17 列出了所有的代码。顺便说一句，有些编译器可能会对无目的赋值(在if条件语句中，通常使用==运算符)提出警告。
、

程序清单 15.17 rtti1.cpp

// rtti1.cpp -- using the RTTI dynamic_cast operator
#include <iostream>
#include <cstdlib>
#include <ctime>

using std::cout;

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()
{
    std::srand(std::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();
    }
    // std::cin.get();
    return 0;
}

Grand * GetOne()    // generate one of three kinds of objects randomly
{
    Grand * p;
    switch( std::rand() % 3)
    {
        case 0: p = new Grand(std::rand() % 100);
                    break;
        case 1: p = new Superb(std::rand() % 100);
                    break;
        case 2: p = new Magnificent(std::rand() % 100, 
                              'A' + std::rand() % 26);
                    break;
    }
    return p; 
}

注意:即使编译器支持RTTI，在默认情况下，它也可能关闭该特性。如果该特性被关闭，程序可能仍能够通过编译，但将出现运行阶段错误。在这种情况下，您应查看文档或菜单选项。

2.typeid 运算符和 type_info 类

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

• 类名;
  *结果为对象的表达式。

typeid 运算符返回一个对 type_info对象的引用,其中,type_info是在头文件typeinfo(以前为typeinfo.h)
中定义的一个类。type_info 类重载了==和!-运算符，以便可以使用这些运算符来对类型进行比较。例如，如果 pg指向的是一个 Magnificent对象，则下述表达式的结果为 bool值true，否则为false:

typeid(Magnificent)== typeid(*pg)

如果 pg是一个空指针，程序将引发 bad_typeid 异常。该异常类型是从exception 类派生而来的，是在头文件 typeinfo 中声明的。
type_info 类的实现随厂商而异，但包含一个name()成员，该函数返回一个随实现而异的字符串:通常(但并非一定)是类的名称。例如，下面的语句显示指针pg指向的对象所属的类定义的字符串:

cout <<"Now processing type " << typeid(*pg) .name()<< ".\n";

程序清单 15.18对程序清单 15.17作了修改，以使用typeid 运算符和name( )成员函数。注意，它们都适用于 dynamic cast 和 virtual函数不能处理的情况。typeid 测试用来选择一种操作，因为操作不是类的方法，所以不能通过类指针调用它。name()方法语句演示了如何将方法用于调试。注意，程序包含了头文件typeinfo.

程序清单 15.18 rtti2.cpp

// rtti2.cpp  -- using dynamic_cast, typeid, and type_info
#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 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 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";
        pg->Speak();
        if( ps = dynamic_cast<Superb *>(pg))
            ps->Say();
        if (typeid(Magnificent) == typeid(*pg))
            cout << "Yes, you're really magnificent.\n";
    }
    // std::cin.get();
    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()来选择类型。另外，调用 name0时，有些编译器可能提供不同的输出，如5Grand(而不是 Grand)。

3.误用RTTI的例子

C++界有很多人对 RTTI口诛笔伐，他们认为 RTT是多余的，是导致程序效率低下和糟糕编程方式的罪魁祸首。这里不讨论对 RTTI的争论，而介绍一下应避免的编程方式。
请看程序清单15.17的核心代码:

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;
Maqnificent *pm;
for(inti=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循环的代码，添加一个 elseif,但无需修改原来的版本。下面的语句适用于所有从 Grand 派生而来的类:

pg->Speak();

而下面的语句适用于所有从 Superb 派生而来的类

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

提示:如果发现在扩展的ifelse 语句系列中使用了typeid，则应考虑是否应该使用虚函数和 dynamic_cast。