C++中reinterpret_cast、const_cast、static_cast、dynamic

C++中reinterpret_cast、const_cast、static_cast、dynamic_cast的作用与区别

1.reinterpret_cast

作用及原理：将一个类型的指针，转换为另一个类型的指针，这种转换不用修改指针变量值数据存放格式（不改变指针变量值），只需在编译时重新解释指针的类型就可以，当然他也可以将指针转换成整型值，但不能做非指针类型转换

 1 #include<iostream>
 2 #include<typeinfo>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     //基本类型指针变换
 9     double d=9.3;
10     double* pd=&d;
11     int *pi=reinterpret_cast<int *>(pd);
12     
13     //不相关的类的指针的类型转换 
14     class A{}; 
15     class B{};
16     A* pa=new A;
17     B* pb=reinterpret_cast<B*>(pa);//相当于隐式转换B* pb=(B*)pa; 
18     
19     //指针转换成整数
20     long j=reinterpret_cast<long>(pi);//相当于隐式转换long j=(long)pi; 
21     
22     return 0;
23 }

2.const_cast

作用及原理：用于去除指针变量的常量属性，将它转换为一个对应的指针类型的普通变量，当然，也可以将一个非常量的指针变量转换为一个常指针变量。这种转换在编译期间

 1 #include<iostream>
 2 #include<typeinfo>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     const int* pci=0;
 9     int* pj=const_cast<int*>(pci);//相当于隐式转换int* pj=(int*)pci;
10     
11     return 0;
12 }

3.static_cast

作用及原理：主要用于基本类型之间和具有继承关系的类型之间的转换

 1 #include<iostream>
 2 #include<typeinfo>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     //基本类型转换 
 9      int i=0;
10      double d=static_cast<double>(i);//相当于隐式转换double d=(double) i; 
11      int j=static_cast<int>(d);//相当于隐式转换int j=(int)d;
12      
13      //转换继承类的对象 
14      class Base{};
15      class Derived:public Base{};
16      Derived D;
17      Base b=static_cast<Base>(D);//将子类对象赋值给父类对象 
18     
19     return 0;
20 }

4.dynamic_cast

作用及其原理：dynamic_cast转换是动态转换，这种转换是在运行时进行转换分析，而不是在编译时期进行，这是区别以上三种转化的一处。dynamic_cast只能在继承类对象的指针之间或引用之间进行转换，进行转换时，会根据当前运行对象的运行类型信息（RTTI），判断类型对象之间的转换是否合法。dynamic_cast的指针转换失败，可通过是否为null指针来检测

 1 #include<iostream>
 2 #include<typeinfo>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8      class Base{};
 9      class Derived:public Base{};
10      //子类指针转换为父类指针 
11      Derived* pd=new Derived;
12      Base* pc=dynamic_cast<Base*>(pd);
13      
14     if(!pc)
15          cout<<"转换失败"<<endl;
16     else
17         cout<<"转换成功"<<endl; 
18         
19     //没有继承关系，但被转换的类有虚函数
20     class A{virtual ~A(){}};//有虚函数
21     class B{};
22     
23     A* pa=new A;
24     B* pb=dynamic_cast<B*>(pa);
25     
26     if(!pb)
27          cout<<"转换失败"<<endl;
28     else
29         cout<<"转换成功"<<endl;  
30     
31     return 0;
32 }

结果如下：

没有继承关系的类之间转换，如果被转换的类有虚函数，编译器会通过，但是转换会失败

总结：

reinterpret_cast适用于指针转换为另一种指针

const_cast适用于常指针变量，可以使常指针变量变为非常指针变量

static_cast主要用于基本类型转换和拥有继承关系变量之间的转换

dynamic_cast只能在继承对象的指针之间或引用之间进行类型转换

注意：需要添加头文件#include<typeinfo>