C++中的四种类型转换运算符static_cast、dynamic_cast、const_cast和reinterpret_cast的使用

1、上一遍讲述了C语言的隐式类型转换和显示类型转换，C语言之所以增加强制类型转换，就是为了强调转换的风险性，但这种强调风险的方式是比较粗放了，粒度比较大，它并没有表明存在什么风险，风险程度如何。

2、为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，C++ 对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：

关键字	说明
static_cast	用于良性转换，一般不会导致意外发生，风险很低。
const_cast	用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast	高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。
dynamic_cast	借助 RTTI，用于类型安全的向下转型（Downcasting）。

这四个关键字的语法格式都是一样的，具体为：

xxx_cast<newType>(data)

newType 是要转换成的新类型，data 是被转换的数据。例如:

老式的C风格的 double 转 int 的写法为：

　　double scores = 95.5;

　　int n = (int)scores;

C++ 新风格的写法为：

　　double scores = 95.5;

　　int n = static_cast<int>(scores);

3、static_cast：

　　一、只能用于良性转换，这样的转换风险较低，一般不会发生什么意外，例如：

• 原有的自动类型转换，例如 short 转 int、int 转 double、向上转型等；
• void 指针和具体类型指针之间的转换，例如void *转int *、char *转void *等；
• 有转换构造函数或者类型转换函数的类与其它类型之间的转换。

　　二、需要注意的是，static_cast 不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：

• 两个具体类型指针之间的转换，例如int *转double *、Student *转int *等。
• int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。

　　三、static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说，不能将 const/volatile 类型转换为非 const/volatile 类型。
　　四、static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

　　下面的代码演示了 static_cast 的正确用法和错误用法：

　　class Complex

　　{

　　public:

　　　　Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }

　　public:

　　　　operator double() const { return m_real; } //类型转换函数

　　private:

　　　　double m_real;

　　　　double m_imag;

　　};

　　

　　int main()

　　{

　　　　//下面是正确的用法

　　　　int m = 100;

　　　　Complex c(12.5, 23.8);

　　　　long n = static_cast<long>(m);　　　　　　　　　　 //宽转换，没有信息丢失

　　　　char ch = static_cast<char>(m); 　　　　　　　　　//窄转换，可能会丢失信息

　　　　int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) ); //将void指针转换为具体类型指针

　　　　void *p2 = static_cast<void*>(p1); 　　　　　　　　//将具体类型指针，转换为void指针

　　　　double real= static_cast<double>(c); 　　　　　　  //调用类型转换函数

　　　　//下面的用法是错误的

　　　　float *p3 = static_cast<float*>(p1); //不能在两个具体类型的指针之间进行转换

　　　　p3 = static_cast<float*>(0X2DF9); //不能将整数转换为指针类型

　　　　return 0;

　　}

4、const_cast:

　　const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。

　　下面的代码说明 const_cast 的用法：

　　int main()

　　{

　　　　const int n = 100;

　　　　int *p = const_cast<int*>(&n);

　　　　*p = 234;

　　　　cout<<"n = "<<n<<endl;　　   //n=100

　　　　cout<<"*p = "<<*p<<endl;　　//*p=234;

　　　　return 0;

　　}

5、reinterpret_cast:

　　reinterpret 是“重新解释”的意思，顾名思义，reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。
　　reinterpret_cast 可以认为是 static_cast 的一种补充，一些 static_cast 不能完成的转换，就可以用 reinterpret_cast 来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换(有些编译器只允许 　　int 转指针,不允许反过来)。
　　下面的代码代码说明 reinterpret_cast 的使用：

　　class A

　　{

　　public:

　　　　A(int a = 0, int b = 0): m_a(a), m_b(b){}

　　private:

 

　　　　int m_a;

　　　　int m_b;

　　};

　　int main()

　　{

　　　　char str[]="http://c.biancheng.net";　　//将 char* 转换为 float*

　　　　float *p1 = reinterpret_cast<float*>(str);

　　　　cout<<*p1<<endl;

　　　　int *p = reinterpret_cast<int*>(100);//将 int 转换为 int*

　　　　p = reinterpret_cast<int*>(new A(25, 96));//将 A* 转换为 int*

　　　　cout<<*p<<endl;

　　　　return 0;

　　}

　　运行结果：

　　3.0262e+29
　　25
　　可以想象，用一个 float 指针来操作一个 char 数组是一件多么荒诞和危险的事情，这样的转换方式不到万不得已的时候不要使用。将A*转换为int*，使用指针直接访问 private 成员刺穿了一个类的封装性，更好的办法是让类提供 get/set 函数，间接地访问成员变量。

6、dynamic_cast:

　　dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型(Upcasting),也允许向下转型(Downcasting)。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。
　　dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。
　　dynamic_cast 的语法格式为：

　　dynamic_cast <newType> (expression)

　　newType 和 expression 必须同时是指针类型或者引用类型。换句话说，dynamic_cast 只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。
　　对于指针，如果转换失败将返回 NULL；对于引用，如果转换失败将抛出std::bad_cast异常。