1. RTTI
RTTI是运行阶段类型识别( Runtime Type Identification)的简称。
这是新添加到C+中的特性之一,很多老式实现不支持。另一些实现可能包含开关RTTI的编译器设置。
RTTI旨在为程序在运行阶段确定对象的类型提供一种标准方式。很多类库已经为其类对象提供了实现这种功能的方式,但由于C++内部并不支持,因此各个厂商的机制通常互不兼容。创建一种RTTI语言标准将使得未来的库能够彼此兼容
2. RTTl的用途
假设有一个类层次结构,其中的类都是从同一个基类派生而来的,则可以让基类指针指向其中任何个类的对象。
这样便可以调用这样的函数:在处理一些信息后,选择一个类,并创建这种类型的对象,然后返回它的地址,而该地址可以被赋给基类指针。如何知道指针指向的是哪种对象呢?
在回答这个问题之前,先考虑为何要知道类型。可能希望调用类方法的正确版本,在这种情况下,只要该函数是类层次结构中所有成员都拥有的虚函数,则并不真正需要知道对象的类型。但派生对象可能包含不是继承而来的方法,在这种情况下,只有某些类型的对象可以使用该方法。也可能是出于调试目的,想跟踪生成的对象的类型。对于后两种情况,RTTI提供解决方案。
3. 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 是 Superb 的基类， Superb 又是 Magnificent 的基类。
接下来假设有下面的指针
Grand *pg = new Grand;
Grand *ps = new Superb;
Grand *pm = new Magnificent;
最后,对于下面的类型转换:
Magnificent *p1 =(Magnificent *)pm; //#1
Magnificent *p2 = (Magnificent *)pg; //#2
Superb *p3 = (Magnificent *)pm; //#3
哪些是安全的?根据类声明,它们可能全都是安全的,但只有那些指针类型与对象的类型(或对象的直接或间接基类的类型)相同的类型转换オ一定是安全的。
例如,类型转换#1就是安全的,因为它将 Magificent 类型的指针指向类型为Magnificent的对象。
类型转换#2就是不安全的,因为它将基类对象( Grand)的地址赋给派生类( Magnificent)指针。因此,程序将期望基类对象有派生类的特征,而通常这是不可能的。例如, 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演示了这种处理。
程序清单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;
}
首先,它定义了3个类,名称为 Grand、 Superb和 Magnificent.
Grand类定义了一个虚函数 Speak(),而其他类都重新定义了该虚函数。 Superb类定义了一个虚函数Say(),而Magnificent也重新定义了它(参见图15.4)。
程序定义了 GetOne()函数,该函数随机创建这3种类中某种类的对象,并对其进行初始化,然后将地址作为 Grand指针返回( GetOne()函数模拟用户做出决定)。循环将该指针赋给 Grand变量pg,然后使用pg调用 Speak()函数。因为这个函数是虚拟的,所以代码能够正确地调用指向的对象的 Speak()版本.
for (int i = 0; i < 5; i++)
{
pg = GetOne();
pg->Speak();
if( ps = dynamic_cast<Superb *>(pg))
ps->Say();
}
然而,不能用相同的方式(即使用指向Grand的指针)来调用Say()函数,因为 Grand类没有定义它。然而,可以使用 dynamic_cast运算符来检査是否可将pg的类型安全地转换为 Superb指针。
如果对象的类型为 Superb或 Magnificent,则可以安全转换。在这两种情况下,都可以安全地调用Say()函数.
if( ps = dynamic_cast<Superb *>(pg))
ps->Say();
}
赋值表达式的值是它左边的值,因此if条件的值为ps。如果类型转换成功,则ps的值为非零(true);如果类型转换失败,即pg指向的是一个 Grand对象,ps的值将为0( false)。
程序清单15.17列出了所有的代码。顺便说一句,有些编译器可能会对无目的赋值(在if条件语句中,通常使用==运算符)提出警告。
注意:即使编译器支持RTTI,在默认情况下,它也可能关闭该特性。如果该特性被关闭,程序可能仍能够通过编译,但将出现运行阶段错误。在这种情况下,您应查看文档或莱单选项。
程序清单15.17中程序说明了重要的一点,即应尽可能使用虚函数,而只在必要时使用 RTTI。
下面是该程序的输出:
book@book-desktop:~/meng-yue/c++/friend_abnormal/04$ g++ -o rtti1 rtti1.cpp
book@book-desktop:~/meng-yue/c++/friend_abnormal/04$ ./rtti1
I am a superb class!!
I hold the superb value of 46!
I am a magnificent class!!!
I hold the character I and the integer 83!
I am a grand class!
I am a superb class!!
I hold the superb value of 10!
I am a grand class!
book@book-desktop:~/meng-yue/c++/friend_abnormal/04$
正如您看到的,只为 Superb和 Magnificent类调用了Say()方法(每次运行时输出都可能不同,因为该程序使用rand()来选择对象类型)。
也可以将 dynamic_cast用于引用,其用法稍微有点不同:没有与空指针对应的引用值,因此无法使用特殊的引用值来指示失败。当请求不正确时, dynamic_cast将引发类型为 bad_cast的异常,这种异常是从exception类派生而来的,它是在头文件 typeinfo中定义的。
因此,可以像下面这样使用该运算符,其中rg是对 Grand对象的引用
#include <typeinfo> //for bad_cast
try {
Superb & rs = dynamic_cast<Superb &>(rg);
}
catch(bad_cast &)
{
};
4. typeid运算符和type_info类
typeid运算符使得能够确定两个对象是否为同种类型。它与 sizeof有些相像,可以接受两种参数:
- 类名;
- 结果为对象的表达式
typeid运算符返回一个对type_info对象的引用,其中,type_info是在头文件typeinfo(以前为 typeinfo.h)中定义的一个类。type_info类重载了==和!运算符,以便可以使用这些运算符来对类型进行比较。
例如**,如果pg指向的是一个 Magnificent对象**,则下述表达式的结果为bool值rtue,否则为 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.18rtti2.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;
}
程序运行的结果：
book@book-desktop:~/meng-yue/c++/friend_abnormal/04$ ./rtti2
Now processing type 6Superb.
I am a superb class!!
I hold the superb value of 56!
Now processing type 5Grand.
I am a grand class!
Now processing type 5Grand.
I am a grand class!
Now processing type 11Magnificent.
I am a magnificent class!!!
I hold the character K and the integer 15!
Yes, you're really magnificent.
Now processing type 6Superb.
I am a superb class!!
I hold the superb value of 67!
book@book-desktop:~/meng-yue/c++/friend_abnormal/04$
与前一个程序的输出一样,每次运行该程序的输出都可能不同,因为它使用rand()来选择类型。另外,调用 name()时,有些编译器可能提供不同的输出,如5Grand(而不是 Grand)。
5. 误用RTTI的例子
C++界有很多人对RTTI口诛笔伐,他们认为RTTI是多余的,是导致程序效率低下和糟糕编程方式的罪魁祸首。这里不讨论对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;
Magnificent *pm;
for(int = 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 *>(p) )
ps->say();
提示: 如果发现在扩展的if else语句系列中使用了 typeid,则应考虑是否应该使用虚函数和 dynamic_cast.
72
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
