C++ 编程思想——运行时类型识别

RTTI的两种使用方法：
1. 第一种是typeid()，它很像sizeof，看上去像一个函数，但实际上它是由编译器实现的。
    typeid()的参数是一个对象引用或者指针，返回全局typeinfo类的常量对象的一个引用。可以用==或者!=来互相比较这些对象。
    ISO C++标准并没有确切定义typeinfo，它的确切定义编译器相关的，但是标准却规定了其实现必需提供如下四种操作：

typeinfo1 == typeinfo2	如果两个对象typeinfo1和typeinfo2类型相同，则返回true；否则返回false
typeinfo1 != typeinfo2	如果两个对象typeinfo1和typeinfo2类型不同，则返回true；否则返回false
typeinfo.name()	可以使用name()来获得类型的名称。例如：cout << typeid(*s).name()
typeinfo1.before(t2)	可以使用before(typeinfo&)来查询一个typeinfo对象是否在另一个typeinfo对象的前面（按照继承顺序

    当typeid操作符的操作数是不带有虚函数的类类型时，typeid操作符会指出操作数的类型，而不是底层对象的类型。
    如果typeid操作符的操作数是至少包含一个虚拟函数的类类型时，并且该表达式是一个基类的应用，则typeid操作符指出底层对象的派生类类型。

    typeid可以运用于非多态类型，但这种方法获得的信息是值得怀疑的。

2. 第二种是“dynamic_cast安全类型向下映射”
    可以使用C++的静态映射static_cast强制执行，但这样做很危险，因为没有办法明确地知道它实际上是什么。
    所以使用dynamic_cast
    shape* sp = new circle;
    circle* cp = dynamic_cast<circle*>(sp);
    if (cp) cout << "cas successful";             // 如果返回一个地址，成功；返回null，说明它不是一个circle* 对象。

　　动态映射不仅可以用来确定准确的类型，也可用于多层次继承关系中的中间类型。
　　typeid总是产生一个typeinfo对象的引用来描述一个对象的准确类型，因此它不会给出中间层次的信息。
　　typeid看到的指针类型是基类，而它看到的引用类型则是派生类。
　　typeid看到的指针指向的类型是派生类，而它看到的引用的地址类型则是基类。
　　多重继承的时候，如果将一个实际指向子类的基类指针做强制转换成子类指针也会出错。

------------------------------两种Bad-cast-----------------------------------
1. dynamic_cast转换一个完全不相关的类
2. typeid操作一个空指针

------------------------------其它语法-----------------------------------
　　static_cast : 为了“行为良好”和“行为较好”而使用的映射，包括一些我们可能现在不用的映射（如向上映射和自动类型转换）。
　　const_cast ：用于映射常量和变量(const和volatile)
　　reinterpret_cast：为了映射到一个完全不同的意思。这是所有映射中最危险的。

 

c++类型识别及转换

1. 概念
　　RTTI（Run-Time Type Information）即运行时类型识别，c++通过RTTI实现对多态的支持。
　　c++是静态类型语言，其数据类型是在编译期就确定的，不能在运行时更改。
　　为了支持RTTI，C++提供了一个type_info类和两个关键字typeid和dynamic_cast。

type_info ：
　　存储特点类型的相关信息，常用来比较对象类型，type_info类的具体内容由编译器实现来决定。其声明如下：

class type_info {
public:
  virtual ~type_info();
  bool operator== (const type_info& rhs) const;
  bool operator!= (const type_info& rhs) const;
  bool before (const type_info& rhs) const;
  const char* name() const;
private:
  type_info (const type_info& rhs);
  type_info& operator= (const type_info& rhs);
};

　　ype_info的构造函数和赋值操作符都为私有，so，不要试图去定义或复制一个type_info对象，程序中创建type_info对象的唯一方法是使用typeid操作符
需要特别注意的是，c++标准只是告诉编译器需要实现type_info::name函数，但是不同的编译器实现各不相同，这意味着：typeid(int).name()不同编译器编译运行后输出不一样。

typeid：
　　typeid表达式形如：typeid(expr)；
　　typeid返回type_info类型，expr可以是各种类型名，对象和内置基本数据类型的实例、指针或者引用，当作用于指针和引用将返回它实际指向对象的类型信息。
　　如果表达式的类型是类类型且至少包含有一个虚函数，则typeid操作符返回表达式的动态类型，需要在运行时计算；否则，typeid操作符返回表达式的静态类型，在编译时就可以计算。
　　当把typeid作用于指针的解引用*p时，若指针p为0，则：如果p指向的类型是带虚函数的类类型，则typeid(*p)在运行时抛出一个bad_typeid异常；否则，typeid(*p)的结果与p的值是不相关的，在编译时就可以确定

dynamic_cast：
　　动态类型转换，运行时类型安全检查。dynamic_cast会检查待转换的源对象是否真的可以转换成目标类型，这种检查不是语法上的，而是真实情况的。许多编译器都是通过vtable找到对象的RTTI信息的，如果基类没有虚方法，也就无法判断一个基类指针变量所指对象的真实类型。
　　dynamic_cast将一个指向基类的指针转换为一个指向派生类的指针，如果不能正确转换，则返回空指针。

2. 其它类型转换符
　　除了dynamic_cast，标准C++中还有其它三个类型转换符：static_cast、reinterpret_cast和const_cas。
　　和dynamic_cast不一样，其它三个类型转换符行为都是在编译期就得以确定的，转换是否成功，并不依赖被转换的对象。
　　const_cast：去掉类型的const或volatile（告诉编译器不要持有变量的临时拷贝）属性。
　　reinterpret_cast ：重新解释类型，常用于不同类型的指针类型转换用。
　　static_cast：类似于C风格的强制转换，静态类型转换。

3.实例
代码:

#include <iostream>
#include <typeinfo>
using namespace std;

struct V_Base 
{
  virtual ~V_Base()
  {
  }
};

struct V_Derived : V_Base 
{
public:
    int _a;
};

struct Base
{
  ~Base()
  {
  }
};

struct Derived : Base
{
public:
    int _a;
};

int main() {
  // built-in types:
  int i;
  int * pi;
  cout << "i is: " << typeid(i).name() << endl;
  cout << "pi is: " << typeid(pi).name() << endl;

  // polymorphic types:
  V_Derived v_derived;
  V_Base* v_pbase = &v_derived;
  cout << "v_derived is: " << typeid(v_derived).name() << endl;
  cout << " *v_pbase is: " << typeid(*v_pbase).name() << endl;
  cout << boolalpha << "same type? "; 
  cout << ( typeid(v_derived)==typeid(*v_pbase) ) << endl << endl; 
  
  // non polymorphic types:
  Derived derived;
  Base* pbase = &derived;
  cout << "derived is: " << typeid(derived).name() << endl;
  cout << " *pbase is: " << typeid(*pbase).name() << endl;
  cout << boolalpha << "same type? "; 
  cout << ( typeid(derived)==typeid(*pbase) ) << endl << endl;

    //polymorphic dynamic_cast
    V_Base* v_pb1 = new V_Derived();
    V_Derived *v_pd1 = static_cast<V_Derived *>(v_pb1); //子类->父类，静态类型转换，正确但不推荐
    V_Derived *v_pd2 = dynamic_cast<V_Derived *>(v_pb1); //子类->父类，动态类型转换，正确
    if(v_pd2 == NULL)
    {
        cout << "v_pd2 dynamic_cast failed" << endl << endl;
    }
    V_Base* v_pb2 = new V_Base();
    V_Derived *v_pd3 = static_cast<V_Derived *>(v_pb2); //父类->子类，静态类型转换，危险！访问子类_a成员越界
    V_Derived *v_pd4 = dynamic_cast<V_Derived *>(v_pb2); //父类->子类，动态类型转换，安全的，结果是NULL
    if(v_pd4 == NULL)
    {
        cout << "v_pd4 dynamic_cast failed" << endl << endl;
    }

    /*
    //non polymorphic dynamic_cast
    Base* pb1 = new Derived();
    Derived *pd1 = static_cast<Derived *>(pb1); 
    Derived *pd2 = dynamic_cast<Derived *>(pb1); //编译错误：error: cannot dynamic_cast ‘pb1’ (of type ‘struct Base*’) to type ‘struct Derived*’ (source type is not polymorphic
    if(pd2 == NULL)
    {
        cout << "pd2 dynamic_cast failed" << endl << endl;
    }
    Base* pb2 = new Base();
    Derived *pd3 = static_cast<Derived *>(pb2);
    Derived *pd4 = dynamic_cast<Derived *>(pb2); //编译错误：error: cannot dynamic_cast ‘pb2’ (of type ‘struct Base*’) to type ‘struct Derived*’ (source type is not polymorphic)
    if(pd4 == NULL)
    {
        cout << "pd4 dynamic_cast failed" << endl << endl;
    }
    */
}

gcc编译，运行输出：
i is: i
pi is: Pi
v_derived is: 9V_Derived
 *v_pbase is: 9V_Derived
same type? true

derived is: 7Derived
 *pbase is: 4Base
same type? false

v_pd4 dynamic_cast failed