程序基石系列之C++运行时类型转换(Runtime Cast)

通过pointer或reference来决定对象运行时类型的一种方法是使用运行时类型转换(runtime cast)，用这种方法可以查证所尝试进行的转换正确与否。当要把基类pointer转换为派生类型时，这种方法非常有用。由于inheritance的层次结构的典型描述是基类在派生类之上，所以这种类型转换也称为向下类型转换(downcast).

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

purge.h代码：

/*
 * 　purge.h
 *
 *  Created on: Feb 22, 2014
 *  Author: Gavin Liu
 */

#ifndef PURGE_H_
#define PURGE_H_

#include <algorithm>

template<class Seq> void purge(Seq& c) {
  typename Seq::iterator i;
  for(i = c.begin(); i != c.end(); ++i) {
    delete *i;
    *i = 0;
  }
}

// Iterator version:
template<class InpIt> void purge(InpIt begin, InpIt end) {
  while(begin != end) {
    delete *begin;
    *begin = 0;
    ++begin;
  }
}

#endif /* PURGE_H_ */

CheckedCast.cpp代码：

/*  Thinking in C ++ Vol. two Practical Programming
 *  CheckedCast.cpp
 *  Checks cast runtime
 *  Created on: Feb 22, 2014
 *  Author: Gavin Liu
 *  Eclipse CDT and GCC
 */

#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 too!" << endl;
  purge(portfolio);
}

其中多态isA()函数检查其参数是否与它的类型参数相容，就意味或id与对象的typeID准确地匹配。

关于程序设计基石与实践更多讨论与交流，敬请关注本博客和新浪微博songzi_tea.