所谓数据类型转换，就是对数据所占用的二进制位做出重新解释。如果有必要，在重新解释的同时还会修改数据，改变它的二进制位。对于隐式类型转换，编译器可以根据已知的转换规则来决定是否需要修改数据的二进制位；而对于强制类型转换，由于没有对应的转换规则，所以能做的事情仅仅是重新解释数据的二进制位，但无法对数据的二进制位做出修正。这就是隐式类型转换和强制类型转换最根本的区别。
四种类型转换符
dynamic static const reinterrupt
xxx_cast<newType>(data)
static转换：
static_cast 只能用于良性转换，这样的转换风险较低，一般不会发生什么意外，例如：
- 原有的自动类型转换，例如 short 转 int、int 转 double、const 转非 const、向上转型等；
- void 指针和具体类型指针之间的转换，例如
void *转int *、char *转void *等； - 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如 double 转 Complex（调用转换构造函数）、Complex 转 double（调用类型转换函数）。
const转换：
const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。
reinterpret_cast：
reinterpret 是“重新解释”的意思，顾名思义，reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。
Dynamic_cast
dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。
dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。
newType 和 expression 必须同时是指针类型或者引用类型。换句话说，dynamic_cast 只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。
对于指针，如果转换失败将返回 NULL；对于引用，如果转换失败将抛出std::bad_cast异常。
向上转型：向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。
向下转型：
向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。那么，哪些向下转型是安全地呢，哪些又是不安全的呢？下面我们通过一个例子来演示。
1 #include <iostream> 2 using namespace std; 3 class A{ 4 public: 5 virtual void func() const { cout<<"Class A"<<endl; } 6 private: 7 int m_a; 8 }; 9 class B: public A{ 10 public: 11 virtual void func() const { cout<<"Class B"<<endl; } 12 private: 13 int m_b; 14 }; 15 class C: public B{ 16 public: 17 virtual void func() const { cout<<"Class C"<<endl; } 18 private: 19 int m_c; 20 }; 21 class D: public C{ 22 public: 23 virtual void func() const { cout<<"Class D"<<endl; } 24 private: 25 int m_d; 26 }; 27 int main(){ 28 A *pa = new A(); 29 B *pb; 30 C *pc; 31 32 //情况① 33 pb = dynamic_cast<B*>(pa); //向下转型失败 34 if(pb == NULL){ 35 cout<<"Downcasting failed: A* to B*"<<endl; 36 }else{ 37 cout<<"Downcasting successfully: A* to B*"<<endl; 38 pb -> func(); 39 } 40 pc = dynamic_cast<C*>(pa); //向下转型失败 41 if(pc == NULL){ 42 cout<<"Downcasting failed: A* to C*"<<endl; 43 }else{ 44 cout<<"Downcasting successfully: A* to C*"<<endl; 45 pc -> func(); 46 } 47 48 cout<<"-------------------------"<<endl; 49 50 //情况② 51 pa = new D(); //向上转型都是允许的 52 pb = dynamic_cast<B*>(pa); //向下转型成功 53 if(pb == NULL){ 54 cout<<"Downcasting failed: A* to B*"<<endl; 55 }else{ 56 cout<<"Downcasting successfully: A* to B*"<<endl; 57 pb -> func(); 58 } 59 pc = dynamic_cast<C*>(pa); //向下转型成功 60 if(pc == NULL){ 61 cout<<"Downcasting failed: A* to C*"<<endl; 62 }else{ 63 cout<<"Downcasting successfully: A* to C*"<<endl; 64 pc -> func(); 65 } 66 67 return 0; 68 }
当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。
对于本例中的情况①，pa 指向 A 类对象，根据该对象找到的就是 A 的类型信息，当程序从这个节点开始向上遍历时，发现 A 的上方没有要转换的 B 类型或 C 类型（实际上 A 的上方没有任何类型了），所以就转换败了。对于情况②，pa 指向 D 类对象，根据该对象找到的就是 D 的类型信息，程序从这个节点向上遍历的过程中，发现了 C 类型和 B 类型，所以就转换成功了。
总起来说，dynamic_cast 会在程序运行过程中遍历继承链，如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如 pa），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果。
从表面上看起来 dynamic_cast 确实能够向下转型，本例也很好地证明了这一点：B 和 C 都是 A 的派生类，我们成功地将 pa 从 A 类型指针转换成了 B 和 C 类型指针。但是从本质上讲，dynamic_cast 还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。本例中的情况②，pa 指向的对象是 D 类型的，pa、pb、pc 都是 D 的基类的指针，所以它们都可以指向 D 类型的对象，dynamic_cast 只是让不同的基类指针指向同一个派生类对象罢了。