C++运行时类型识别

当仅有一个指针或引用指向基类型时，利用运行时类型识别（RTTI）可以找到一个对象的动态类型。

运行时类型识别可能被认为是C++中一个”次要“的特征，当程序员在编程过程中陷入非常困难的境地时，实用主义将会帮助他走出困境。正常情况下，程序员需要有意忽略对象的准确类型，而利用虚函数机制实现那个类型正确操作过程。然而，有时知道一个仅含一个基类指针的对象的准确的运行时类型（即多半是派生的类型）是非常有用的。有了此信息，就可以更有效地进行某些特殊情况的操作，或者预防基类接口因无此信息而变得笨拙。

1.运行时类型转换

通过指针或者引用决定对象运行时类型的一种方法是使用运行时类型转换（runtime cast），用这种方法可以查证所尝试进行的转换正确与否。当要把基类指针类型转换为派生类时，这个方法非常有用。由于继承的层次结构的典型描述说基类在派生类之上，所以这种类型转换也成为向下类型转换（downcast）。

请看下面的类层次结构：

在下面的程序代码中，Investment类中有一个其他类没有的额外操作，所以能够运行时知道Security指针是否引用了Investment对象是很重要的。为了实现检查运行时的类型转换，每个类都持有一个整数标识符，以便可以与层次结构中其他的类区别开来。

#include <iostream>
#include <vector>
#include "../purge.h"
using namespace std;

class Security {
   
protected:
  enum {
    BASEID = 0 };
public:
  virtual ~Security() {
   }
  virtual bool isA(int id) {
    return (id == BASEID); }
};

class Stock : public Security {
   
  typedef Security Super;
protected:
  enum {
    OFFSET = 1, TYPEID = BASEID + OFFSET };
public:
  bool isA(int id) {
   
    return id == TYPEID || Super::isA(id);
  }
  static Stock* dynacast(Security* s) {
   
    return (s->isA(TYPEID)) ? static_cast<Stock*>(s) : 0;
  }
};

class Bond : public Security {
   
  typedef Security Super;
protected:
  enum {
    OFFSET = 2, TYPEID = BASEID + OFFSET };
public:
  bool isA(int id) {
   
    return id == TYPEID || Super::isA(id);
  }
  static Bond* dynacast(Security* s) {
   
    return (s->isA(TYPEID)) ? static_cast<Bond*>(s) : 0;
  }
};

class Investment : public Security {
   
  typedef Security Super;
protected:
  enum {
    OFFSET = 3, TYPEID = BASEID + OFFSET };
public:
  bool isA(int id) {
   
    return id == TYPEID || Super::isA(id);
  }
  static Investment* dynacast(Security* s) {
   
    return (s->isA(TYPEID)) ?
      static_cast<Investment*>(s) : 0;
  }
  void special() {
   
    cout << "special Investment function" << endl;
  }
};

class Metal : public Investment {
   
  typedef Investment Super;
protected:
  enum {
    OFFSET = 4, TYPEID = BASEID + OFFSET };
public:
  bool isA(int id) {
   
    return id == TYPEID || Super::isA(id);
  }
  static Metal* dynacast(Security* s) {
   
    return (s->isA(TYPEID)) ? static_cast<Metal*>(s) : 0;
  }
};

int main() {
   
  vector<Security*> portfolio;
  portfolio.push_back(new Metal);
  portfolio.push_back(new Investment);
  portfolio.push_back(new Bond);
  portfolio.push_back(new Stock);
  for(vector<Security*>::iterator it = portfolio.begin();
       it != portfolio.end(); ++it) {
   
    Investment* cm = Investment::dynacast(*it);
    if(cm)
      cm->special();
    else
      cout << "not an Investment" << endl;
  }
  cout << "cast from intermediate pointer:" << endl;
  Security* sp = new Metal;
  Investment* cp = Investment::dynacast(sp);
  if(cp) cout << "  it's an Investment" << endl;
  Metal* mp = Metal::dynacast(sp);
  if(mp) cout << "  it's a Metal t