面向对象编程的一个特点是运行时进行类型识别，这是对面向对象中多态的支持，使用 RTTI 能够使类的设计更加抽象，更加符合人们的思维。
运行时类型识别（Run-time type identification，RTTI）是在只有一个指向基类的指针或引用时所确定的一个对象的类型。
在编写程序时，往往只提供一个对象的指针，但通常在使用时，需要明确这个指针的确切类型。利用 RTTI 就可以方便地获取某个对象指针的确切类型并进行控制。
一般情况下，在编译期间就能确定一个表达式的类型，但是当存在多态时，有些表达式的类型在编译期间就无法确定了，必须等到程序运行后根据实际的环境来确定。
首先，分析以下如下代码：
class A
{
public:
virtual void print() = 0;
};
class B:public A
{
public:
void print()
{
cout << "我是B，是A的孩子" << endl;
}
};
class C:public A
{
public:
void print()
{
cout << "我是C，是A的孩子" << endl;
}
};
void print(A* a)
{
a->print();
}
int main() {
A* b = new B();
print(b);
A* c = new C();
print(c);
return 0;
}
A 是父类，B和C是A的子类，通过向上转型的方式定义两个指针：
A* b = new B();
A* c = new C();
b指针指向对象B，c指针指向对象C，它们的输出结果是：
我是B，是A的孩子
我是C，是A的孩子
对于 print 函数，它的形式参数是父类A的指针，至于该指针到底指向哪个子类， print 函数并不知晓，如果想在 print 函数中确定指向目标的数据类型，需要丰富一下 print 函数：
void print(A* a)
{
const type_info& info = typeid(*a);
cout << info.name() << endl;
a->print();
}
使用 typeid 将指针a所指向的子类类名打印出来，打印结果是：
class B
我是B，是A的孩子
class C
我是C，是A的孩子
基类中包含了一个虚函数，派生类 B 和 C又定义了一个原型相同的函数遮蔽了它，这就构成了多态。
a 是基类的指针，可以指向基类对象，也可以指向派生类对象；*a表示 a 指向的对象。
在 C++ 中，只有类中包含了虚函数时才会启用 RTTI 机制，其他所有情况都可以在编译阶段确定类型信息。
下面开始举一个关于 RTTI 应用的例子，根据不同类型执行不同的操作，代码如下：
#include <iostream>
#include <typeinfo>
using namespace std;
class A
{
public:
virtual void print() = 0;
};
class B:public A
{
public:
void print()
{
cout << "我是B，是A的孩子" << endl;
}
};
class C:public A
{
public:
void print()
{
cout << "我是C，是A的孩子" << endl;
}
};
void print(A* a)
{
const type_info& info = typeid(*a);
const type_info& bInfo = typeid(B);
const type_info& cInfo = typeid(C);
if (info.operator==(bInfo)) // 如果a指向B
{
B* b = dynamic_cast<B*>(a);
if (b != NULL) // 如果指针b没有指向NULL
{
b->print();
}
else
{
cout << "指针b异常" << endl;
}
}
else if (info.operator==(cInfo)) // 如果a指向B
{
C* c = dynamic_cast<C*>(a);
if (c != NULL) // 如果指针b没有指向NULL
{
c->print();
}
else
{
cout << "指针c异常" << endl;
}
}
}
int main() {
A* b = new B();
print(b);
A* c = new C();
print(c);
return 0;
}
代码中将 dynamic_cast 和 typeid 相互结合使用，可以很好的体现 RTTI 机制。
[本章完...]
