c++中四种类型转换

reinterpret_cast<目标类型>(原类型变量)//重解释类型转换
dynamic_cast<new_type>(expression)//动态类型转换
static_cast<new_type>(expression)//静态类型转换
const_cast<new_type>(expression)//返回一个指向非常量的指针

1.const_cast：常量指针被转化成非常量的指针，并且仍然指向原来的对象；常量引用被转换成非常量的引用，并且仍然指向原来的对象；

const int a = 100;
    const int* p1 = &a;
    *p1 = 200; // ERROR
    int* p2 = const_cast<int*> (p1);
    *p2 = 200; // OK

class A{};
   const A *a = new A;
   A *b= const_cast<A*> (a);
   A &c= const_cast<A&> (*a);

2. 动态类型转换：用在具有多态性的父子类指针或引用之间。动态类型转换是站在指针指向的对象的角度进行检查，编译总没错误，但是在在执行阶段，会以返回空指针的方式提示失败，如果是引用则抛出异常，被系统捕获然后杀死进程，这种转换形式是最安全的

3. 静态类型转换：如果在目标类型和源类型之间某一个方向上可以做隐式类型转换，那么在两个方向上都可以做静态类型转换。反之如果在两个方向上都不能做隐式类型转换，那么在任意一个方向上也不能做静态类型转换。静态类型转换是站在指针类型的角度进行检查，这个过程是在编译阶段进行的。

4. 重解释类型转换：在不同类型的指针或引用之间做类型转换，以及在指针和整型之间做类型转换。无论编译阶段还是执行阶段都不会进行类型检查，只是负责把一种类型转成另一种类型，这种转换形式最危险的。

#include <iostream>
using namespace std;
class A { virtual void foo (void) {} };
class B : public A {};
class C : public B {};
class D {};
int main (void) {
	B b;
	A* pa = &b;
	cout << pa << endl;
	cout << "--------  动态转换dc--------" << endl;
	// pa指向B对象，所以成功
	B* pb = dynamic_cast<B*> (pa);
	cout << pb << endl;
	// pa没有指向C对象，失败，安全
	C* pc = dynamic_cast<C*> (pa);
	cout << pc << endl;
	A& ra = b;
	try {
		C& rc = dynamic_cast<C&> (ra);
	}
	catch (exception& ex) {
		cout << "类型转换失败：" << ex.what ()
			<< endl;
		// ...
	}
	// pa没有指向D对象，失败，安全
	D* pd = dynamic_cast<D*> (pa);
	cout << pd << endl;
	
	cout << "-------- 静态转换sc --------" << endl;
	// B是A的子类，所以成功
	pb = static_cast<B*> (pa);
	cout << pb << endl;
	// C是A的孙子类，成功，危险！
	pc = static_cast<C*> (pa);
	cout << pc << endl;
	// D不是A的后裔，失败，安全
//	pd = static_cast<D*> (pa);
//	cout << pd << endl;

	cout << "-------- 重解释rc --------" << endl;
	// 无论在编译期还是在运行期都不做检查，危险！
	pb = reinterpret_cast<B*> (pa);
	cout << pb << endl;
	pc = reinterpret_cast<C*> (pa);
	cout << pc << endl;
	pd = reinterpret_cast<D*> (pa);
	cout << pd << endl;
	return 0;
}