RTTI，C++类型转换操作符

body, table{font-family: 微软雅黑; font-size: 10pt}
table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;}
th{border: 1px solid gray; padding: 4px; background-color: #DDD;}
td{border: 1px solid gray; padding: 4px;}
tr:nth-child(2n){background-color: #f8f8f8;}

RTTI、 typeid、类型转换操作符：

——RTTI，是RunTime Type Identification的缩写，称“运行时类型识别”，这是C++中相对较新的特性，一些老式的编译器可能不支持，不同编译器的实现方法也不尽相同。

---

RTTI机制：

★C++是一种静态类型语言。其数据类型是在编译期就确定的，不能在运行时更改。虚函数的使用使得动态联编成为可能，举例来说，存在一个类层次结构A->B->C，结构定义为;

     class A{…};                //包含虚函数

      class B: public  A{…};

      class C: public  B{…};

★此时，可以直接用派生类（B类或C类）对象为A类指针赋值，而且，通过该A类指针调用虚成员函数时，调用的版本是为其赋值的派生类对此虚函数的覆盖定义。当然，不可能把所有函数都定义成虚函数，对派生类中定义的普通函数来说，使用A类指针调用该函数是否合法需要具体分析。

★先来看如下的强制类型转换机制：

     A *pa = new B;

      B *pb = (B *)pa;        //直接赋值编译器会报错, 需要强制转换

★上述代码是很安全的, 因为pa指向的堆空间中存储的恰好为B类对象，此时使用pb调用B类中定义的非虚函数不会出错。看另一个转换：

    A *pa = new A;

     B *pb = (B *)pa;

★虽然编译器不会报错，但上述代码明显不安全，存在问题，此时使用pb调用B类中的非虚函数必然会出错。

---

dynamic_cast操作符：

★综合来看，使用派生类对象为基类指针赋值是安全的，可什么时候使用基类指针为派生类指针赋值是安全的呢？C++提供了操作符dynamic_cast，其语法是：

                                          CSon *p1 = dynamic_cast<CSon*>(pBase);

★其中pBase是基类指针，CSon是派生类型，如果pBase指向的对象是CSon型或CSon的派生类型，指针转换成功；否则，p1为null，即空指针。

#include <iostream> using namespace std; class A {         public:                 virtual void disp()                 {   cout<<"A::disp()"<<endl;   }                 void printA()                 {   cout<<"A::printA()"<<endl;   } }; class B : public A {         public:                 void disp()                 {   cout<<"B::disp()"<<endl;   }                 void printB()                 {   cout<<"B::printB()"<<endl;   } }; int main() {         A *pa = new B;         B *pb = dynamic_cast<B *>(pa);    //转换安全         if(pb != NULL)         {   pb->printB();   }         else         {   cout<<"转换不安全，退出"<<endl;   }         A *p1 = new A;         B *p2 = dynamic_cast<B *>(p1);    //转换不安全         if(p2 != NULL)         {   p2->printB();   }         else         {   cout<<"转换不安全，退出"<<endl;   }         return 0; }

#include <iostream> #include <typeinfo> #include <string.h> using namespace std; class Animal //抽象类 {         public:                 virtual void Say()=0;  //纯虚函数 }; class Dog:public Animal {         public:                 void Say()                 {   cout<<"汪汪"<<endl;   } }; class Cat:public Animal {         public:                 void Say()                 {   cout<<"喵喵"<<endl;   } }; void play(Animal *pa) {         if(typeid(*pa) == typeid(Dog))  //判断当前指针是不是Dog类型         {                 Dog * dog = dynamic_cast<Dog*>(pa);                 dog->Say();         }         if(typeid(*pa) == typeid(Cat))         {                 Cat * cat = dynamic_cast<Cat*>(pa);                 cat->Say();         } }

int main() {         Dog dog;         Animal *a = &dog;         cout<<typeid(double).name()<<endl;  //只输出类型第一个字母         cout<<typeid(5).name()<<endl;         cout<<"typeid(a).name() "<<typeid(a).name()<<endl; //指针类型         cout<<"typeid(*a).name() "<<typeid(*a).name()<<endl; //指针所存的值类型         play(a);         Cat cat;         play(&cat); }

typeinfo类和typeid操作符：

★在头文件 #include<typeinfo> 中还定义了typeinfo类和typeid操作符，从typeid的字面即可看出，该操作符用以返回类的id，即类型信息，其基本调用格式为： typeinfo&  typeid(expr);    参数expr可以是单个对象，也可以是返回结果为对象的表达式，还可以是类名；返回值是一个typeinfo对象的引用，如果expr是类对象（或类名）、且至少包含有一个虚函数，typeid操作符返回的typeinfo对象需要在运行时计算；否则，返回一个静态对象，在编译时就可以计算得到。

★typeinfo类中包含了一个  name()   成员，返回一个字符串，通常是类名，如下述语句返回的均为静态typeinfo对象:

cout<<typeid(5).name()<<endl;                  //输出字符串“int”

cout<<typeid(double).name()<<endl;        //输出字符串“double”

★来看一个返回动态typeinfo对象的例子：

class A{……}；                //包含虚函数

class B：pulic A{……}

A* pa=new B;

cout<<typeid(*pa).name()<<endl;        //输出结果为B

★typeinfo类中对 == 和 != 进行了重载，因此可以使用typeid来判断变量是哪种类型。如语句 if (typeid(x) == typeid(double)) 用来判断变量x的类型是否double类型。

---

 ●RTTI只能应用于包含虚函数的类层次中，只有在虚函数处理上，使用派生类对象给基类指针赋值才有意义。如果类层次中没有虚函数，将派生类赋值给基类指针没有实质意义。RTTI的引入，可检查基类指针向派生类指针的转换是否安全，为类层次中非虚函数和数据成员的调用提供了方法

---

类型转换操作符：

★包括dynamic_cast，C++中共添加了4个类型转换符，用以对数据类型的转换进行更严格的限制，分别是dynamic_cast、const_cast、static_cast和reinterpret_cast，和前面所讲的类型转换机制相比，新机制让程序员根据需要选择要使用的操作符，明确了转换意图，可读性更强，而且，编译器可方便地对转换是否安全进行检查，能排查很多传统类型转换无法找出的问题，动态操作符dynamic_cast已在上节介绍过，它将一个指向派生类的基类指针或引用转换为派生类的指针或引用，注意dynamic_cast转换符只能用于含有虚函数的类。

---

static_cast操作符：

★static_cast的基本语法为：static_cast<T>(expr);     该运算符把expr转换为T型，仅当T类型与expr所属类型能相互隐式转换时，上述转换才合法；否则会报错，能及时发现错误（例如不能把两个不相关的类相互转化）。主要有如下几种用法：

●用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。

●用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。

●把空指针转换成目标类型的空指针。

●把任何类型的表达式转换成void类型。

---

const_cast操作符：

★const_cast的基本使用格式为：   const_cast<T>(expr);

★const_cast最常用的用途就是删除const属性，如果某个变量在大多数时候是常量，而在某个时候又是需要修改的，这时就可以使用const_cast操作符了。expr应该为指针和引用的形式，该操作符不会影响expr，除了const和volatile修饰符等，T应与expr类型相同，返回一个新的T型变量，与expr有相同的值。

#include <iostream> #include <typeinfo> using namespace std; int main() {         const int i=5;         const int *pi=&i;         //*pi = 6;   //不能更改         cout<<"i= "<<i<<endl;         cout<<"*pi = "<<*pi<<endl;         cout<<"pi = "<<pi<<endl;         int *pi1=const_cast<int *>(pi);     //为什么这样？因为const int *不能初始化int * //去除pi的const属性,返回新类型变量，不会影响i         *pi1 = 6;         //*pi = 6;   //不能更改         cout<<"i= "<<i<<endl;         cout<<"*pi = "<<*pi<<endl;         cout<<"pi = "<<pi<<endl;         cout<<"*pi1 = "<<*pi1<<endl;         cout<<"pi1 = "<<pi1<<endl;         *(const_cast<int *>(pi))=6;  //前面操作可合并为这个         return 0; }

#include <iostream> using namespace std; int main() {         double d = 2.5;         double *pd = &d;         int *pi = reinterpret_cast<int *>(pd);         //int *pi1 = static_cast<int *>(pd);  //error         //int *pi2 = dynamic_cast<int *>(pd); //error         int *pi3 = (int *)(pd);         cout<<"pd= "<<pd<<"\t\tpi= "<<pi<<"\t\tpi3= "<<pi3<<endl;  //因为指针类型不同，所以值不同         cout<<"*pi= "<<*pi<<"\t\t*pi3= "<<*pi3<<endl;         int a = 3;   //这里必须int         int *a1 = reinterpret_cast<int *>(a);        //整形量转换为指针，只能值int类型         double *a2 = reinterpret_cast<double *>(a);         cout<<"a1= "<<a1<<"\t\ta2= "<<a2<<endl;         cout<<"*a1= "<<*a1<<"\t\t*a2= "<<*a2<<endl;   //段错误         return 0; }

---

reinterpret_cast操作符：

★reinterpret_cast的调用格式：    reinterpret_cast<T>(expr)

★reinterpret_cast无法保证转换的安全性，用来将一个类型的指针转变为另一种类型的指针，也用在将整型量转为指针，或将指针转为整型量上。

reinterpret(重新解释)

---

◆RTTI机制特性能让程序在运行时检测对象的类型，不以指针为转换是否安全的依据，而是考虑指针指向的对象，更本质地说，考虑的是指针指向的内存块的有效性，因而能保证使用指针安全调用虚函数和普通函数。typeid操作符返回一个typeinfo对象的引用，通过typeinfo类提供的name成员函数可以输出参数所属类名。

◆C++中新增的4个类型转换操作符，和传统的类型转换相比，新增的4个cast操作符很好地保证了类型转换的安全性，直观体现了程序员的意图，编译器可很好地进行查错处理。

#include<iostream> using namespace std; class point {         public:                 point(int x=0,int y=0):_x(x),_y(y){}                 virtual void show()                 {                         cout<<"("<<_x<<","<<_y;                 }         private:                 int _x;                 int _y; }; class point3D:public point {         public:                 point3D(int _x=0,int _y=0,int z=0):point(_x,_y),_z(z){}                 virtual void show()                 {                         point::show();                         cout<<","<<_z<<")"<<endl;                 }         private:                 int _z; }; class String {         public:                 String():_mchar(new char[1]){}                 void show()                 {                         cout<<_mchar<<endl;                 }         private:                 char* _mchar; };

int main() {         //下面的转换本来是无意义和非法的，以后使用ps->Show()         //成员函数时可能会引起内存错误或得到错误的值, 但编译却不出错. 留下隐患         point3D p1(1,2,3);         String* sp = (String*)&p1;         sp->show();  // 编译通过，调用直接段错误  // 派生类里面加了point::限定就不会段错误了         //但改成下面使用static_cast形式进行转换, 在编译时就报错, 能及时发现错误         //sp = static_cast<String*> (&p1);  // 编译报错         cout<<"----------------------------------------------------------------"<<endl;         //而下面这种转换之所以能编译通过，是因为CPoint和CPoint3D的指针本来就可以相互转换         point* pBase = static_cast<point*> (&p1);         pBase->show();         cout<<endl;         return 0; }