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;
}