2.6.1 C++四种强制类型转换

前言

C++即支持C风格的类型转换,又有自己风格的类型转换。C风格的转换格式很简单,但是有不少缺点的:

  1.转换太过随意,可以在任意类型之间转换。你可以把一个指向const对象的指针转换成指向非const对象的指针,把一个指向基类对象的指针转换成一个派生类对象的指针,这些转换之间的差距是非常巨大的,但是传统的C语言风格的类型转换没有区分这些。

  2.C风格的转换没有统一的关键字和标示符。对于大型系统,做代码排查时容易遗漏和忽略。

  C++风格完美的解决了上面两个问题。1.对类型转换做了细分,提供了四种不同类型转换,以支持不同需求的转换;2.类型转换有了统一的标示符,利于代码排查和检视。下面分别来介绍这四种转换:static_cast、dynamic_cast、const_cast和reinterpre_cast.

一、static_cast转换

  1.基本用法:static_cast expression

  2.使用场景:

  a、用于类层次结构中基类和派生类之间指针或引用的转换

  上行转换(派生类——>基类)是安全的;

  下行转换(基类——>派生类)由于没有动态类型检查,所以是不安全的。

  b、用于基本数据类型之间的转换,如把int转换为char,这种带来安全性问题由程序员来保证

  c、把空指针转换成目标类型的空指针

  d、把任何类型的表达式转为void类型

  3.使用特点

  a、主要执行非多态的转换操作,用于代替C中通常的转换操作

  b、隐式转换都建议使用static_cast进行标明和替换

注意:static_cast不能转换掉expression的const、volatile、或者__unaligned属性。

基本类型数据转换举例如下:

  1. char a = 'a';
  2. int b = static_cast<char>(a);//正确,将char型数据转换成int型数据
  3. double *c = new double;
  4. void *d = static_cast<void*>(c);//正确,将double指针转换成void指针
  5. int e = 10;
  6. const int f = static_cast<const int>(e);//正确,将int型数据转换成const int型数据
  7. const int g = 20;
  8. int *h = static_cast<int*>(&g);//编译错误,static_cast不能转换掉g的const属性

类上行和下行转换:

  1. if(Derived *dp = static_cast<Derived *>(bp)){//下行转换是不安全的
  2. //使用dp指向的Derived对象
  3. }
  4. else{
  5. //使用bp指向的Base对象
  6. }
  7. if(Base*bp = static_cast<Derived *>(dp)){//上行转换是安全的
  8. //使用bp指向的Derived对象
  9. }
  10. else{
  11. //使用dp指向的Base对象
  12. }

二、dynamic_cast转换

  1.基本用法:

  1. dynamic_cast<type*>(e)
  2. dynamic_cast<type&>(e)
  3. dynamic_cast<type&&>(e)

  type必须是一个类类型,在第一种形式中,type必须是一个有效的指针,在第二种形式中,type必须是一个左值,在第三种形式中,type必须是一个右值。在上面所有形式中,e的类型必须符合以下三个条件中的任何一个:e的类型是是目标类型type的公有派生类、e的类型是目标type的共有基类或者e的类型就是目标type的的类型。如果一条dynamic_cast语句的转换目标是指针类型并且失败了,则结果为0。如果转换目标是引用类型并且失败了,则dynamic_cast运算符将抛出一个std::bad_cast异常(该异常定义在typeinfo标准库头文件中)。e也可以是一个空指针,结果是所需类型的空指针。

  2.使用场景:只有在派生类之间转换时才使用dynamic_cast,type-id必须是类指针,类引用或者void*。

  3.使用特点:

  a、基类必须要有虚函数,因为dynamic_cast是运行时类型检查,需要运行时类型信息,而这个信息是存储在类的虚函数表中,只有一个类定义了虚函数,才会有虚函数表(如果一个类没有虚函数,那么一般意义上,这个类的设计者也不想它成为一个基类)。

  b、对于下行转换,dynamic_cast是安全的(当类型不一致时,转换过来的是空指针),而static_cast是不安全的(当类型不一致时,转换过来的是错误意义的指针,可能造成踩内存,非法访问等各种问题)。在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。dynamic_cast是唯一无法由旧式语法执行的动作,也是唯一可能耗费重大运行成本的转型动作。

  c、dynamic_cast还可以进行交叉转换

(1)指针类型

举例,Base为包含至少一个虚函数的基类,Derived是Base的共有派生类,如果有一个指向Base的指针bp,我们可以在运行时将它转换成指向Derived的指针,代码如下:

  1. if(Derived *dp = dynamic_cast<Derived *>(bp)){
  2. //使用dp指向的Derived对象
  3. }
  4. else{
  5. //使用bp指向的Base对象
  6. }

值得注意的是,在上述代码中,if语句中定义了dp,这样做的好处是可以在一个操作中同时完成类型转换和条件检查两项任务。

(2)引用类型

因为不存在所谓空引用,所以引用类型的dynamic_cast转换与指针类型不同,在引用转换失败时,会抛出std::bad_cast异常,该异常定义在头文件typeinfo中。

  1. void f(const Base &b){
  2. try{
  3. const Derived &d = dynamic_cast<const Base &>(b);
  4. //使用b引用的Derived对象
  5. }
  6. catch(std::bad_cast){
  7. //处理类型转换失败的情况
  8. }
  9. }

三、const_cast转换

  1.基本用法:const_castexpression

  2.使用场景:

  a、常量指针转换为非常量指针,并且仍然指向原来的对象

  b、常量引用被转换为非常量引用,并且仍然指向原来的对象

  3.使用特点:

  a、const_cast用于修改类型的const或volatile属性。 cosnt_cast是四种类型转换符中唯一可以对常量进行操作的转换符

  b、去除常量性是一个危险的动作,尽量避免使用。一个特定的场景是:类通过const提供重载时,一般都是非常量函数调用const_cast将参数转换为常量,然后调用常量函数,然后得到结果再调用const_cast 去除常量性。

该运算符用来修改类型的const(唯一有此能力的C++-style转型操作符)或volatile属性。除了const 或volatile修饰之外, new_type和expression的类型是一样的。

①常量指针被转化成非常量的指针,并且仍然指向原来的对象;

②常量引用被转换成非常量的引用,并且仍然指向原来的对象;

③const_cast一般用于修改底指针。如const char *p形式。

举例转换如下:

  1. const int g = 20;
  2. int *h = const_cast<int*>(&g);//去掉const常量const属性
  3. const int g = 20;
  4. int &h = const_cast<int &>(g);//去掉const引用const属性
  5. const char *g = "hello";
  6. char *h = const_cast<char *>(g);//去掉const指针const属性

四、reinterpret_cast转换

  1.基本用法:reinterpret_castexpression

  2.使用场景:不到万不得已,不用使用这个转换符,高危操作

  3.使用特点:  

  a、reinterpret_cast是从底层对数据进行重新解释,依赖具体的平台,可移植性差

  b、reinterpret_cast可以将整型转换为指针,也可以把指针转换为数组

  c、reinterpret_cast可以在指针和引用里进行肆无忌惮的转换

new_type必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数,也可以把一个整数转换成一个指针(先把一个指针转换成一个整数,再把该整数转换成原类型的指针,还可以得到原先的指针值)。

reinterpret_cast意图执行低级转型,实际动作(及结果)可能取决于编辑器,这也就表示它不可移植

  举一个错误使用reintepret_cast例子,将整数类型转换成函数指针后,vc++在执行过程中会报”…中的 0xxxxxxxxx 处有未经处理的异常: 0xC0000005: Access violation”错误:

  1. #include <iostream>
  2. using namespace std;
  3. int output(int p){
  4. cout << p <<endl;
  5.   return 0;
  6. }
  7. typedef int (*test_func)(int );//定义函数指针test_func
  8. int main(){
  9. int p = 10;
  10. test_func fun1 = output;
  11. fun1(p);//正确
  12. test_func fun2 = reinterpret_cast<test_func>(&p);
  13. fun2(p);//...处有未经处理的异常: 0xC0000005: Access violation
  14. return 0;
  15. }

IBM的C++指南、C++之父Bjarne Stroustrup的FAQ网页MSDN的Visual C++也都指出:错误的使用reinterpret_cast很容易导致程序的不安全,只有将转换后的类型值转换回到其原始类型,这样才是正确使用reinterpret_cast方式。

  MSDN中也提到了,实际中可将reinterpret_cast应用到哈希函数中,如下(64位系统中需将unsigned int修改为unsigned long):

  1. // expre_reinterpret_cast_Operator.cpp
  2. // compile with: /EHsc
  3. #include <iostream>
  4. // Returns a hash code based on an address
  5. unsigned short Hash( void *p ) {
  6. unsigned int val = reinterpret_cast<unsigned int>( p );
  7. return ( unsigned short )( val ^ (val >> 16));
  8. }
  9. using namespace std;
  10. int main() {
  11. int a[20];
  12. for ( int i = 0; i < 20; i++ )
  13. cout << Hash( a + i ) << endl;
  14. }

另外,static_cast和reinterpret_cast的区别主要在于多重继承,比如

  1. class A {
  2. public:
  3. int m_a;
  4. };
  5. class B {
  6. public:
  7. int m_b;
  8. };
  9. class C : public A, public B {};

那么对于以下代码:

  1. C c;
  2. printf("%p, %p, %p", &c, reinterpret_cast<B*>(&c), static_cast <B*>(&c));

 前两个的输出值是相同的,最后一个则会在原基础上偏移4个字节,这是因为static_cast计算了父子类指针转换的偏移量,并将之转换到正确的地址(c里面有m_a,m_b,转换为B*指针后指到m_b处),而reinterpret_cast却不会做这一层转换。

 因此, 你需要谨慎使用 reinterpret_cast。

五、各种转换之间的比较

  1.static_cast和dynamic_cast

  1. class Base
  2. {
  3. public:
  4. Base(int c = 2):_c(c){}
  5. public:
  6. int _c;
  7. };
  8. class Derived:public Base
  9. {
  10. public:
  11. int _d;
  12. int _e;
  13. };
  14. int main(void)
  15. {
  16. int tempA = 2;
  17. int tempB = 3;
  18. Base base;
  19. /*1.无编译告警,但是危险操作,譬如说调用drvPtrA->_d会造成不可预知的后果*/
  20. Derived *drvPtrA = static_cast<Derived *>(&base);
  21. drvPtrA->_d = 4;
  22. drvPtrA->_e = 5;
  23. /*2.输出:tempA为5,tempB为4,踩内存了(机器信息:32位ubuntu,编译器clang++)*/
  24. cout<<tempA<<endl;
  25. cout<<tempB<<endl;
  26. /*3.Base中没有虚函数,无法查看运行时信息,编译不过*/
  27. Derived *drvPtrB = dynamic_cast<Derived *>(base);
  28. return 0;
  29. }

  在基类派生类互相转换时,虽然static_cast是在编译期完成,效率更高,但是不安全,上例中就示范了一个踩内存的例子。相比之下因为dynamic_cast可以查看运行时信息,上例如果Base含有虚函数,那么drvPtrB就是一个空指针(这可比踩内存什么的好多了),不能操作Derived中_d的数据从而保证安全性,所以应该优先使用dynamic_cast。

  2.static_cast和reinterpret_cast

  1. class BaseA
  2. {
  3. public:
  4. BaseA(int c = 2):_c(c){}
  5. int _c;
  6. };
  7. class BaseB
  8. {
  9. public:
  10. BaseB(int d = 3):_d(d){}
  11. int _d;
  12. };
  13. int main(void)
  14. {
  15. BaseA baseA;
  16. /*1.编译不过*/
  17. BaseB *baseB = static_cast<BaseB *>(&baseA);
  18. /*2.无任何编译告警,编译通过,正常运行*/
  19. BaseB *baseC = reinterpret_cast<BaseB *>(&baseA);
  20. cout<<baseC->_d<<endl;
  21. return 0;
  22. }

  static_cast虽然也不是一种绝对安全的转换,但是它在转换时,还是会进行必要的检测(诸如指针越界计算,类型检查)。reinterpret_cast完全是肆无忌惮,直接从二进制开始重新映射解释,是极度不安全的,再次提醒,不到万不得已,不要使用。

六、c++强制转换注意事项

​ 新式转换较旧式转换更受欢迎。原因有二,一是新式转型较易辨别,能简化“找出类型系统在哪个地方被破坏”的过程;二是各转型动作的目标愈窄化,编译器愈能诊断出错误的运用。 尽量少使用转型操作,尤其是dynamic_cast,耗时较高,会导致性能的下降,尽量使用其他方法替代。