C++ 中static_cast、dynamic_cast、const_cast和reinterpret_cast总结

水深无声 2023-02-28 04:07 1阅读 0赞

C++中的类型转换分为两种：  
隐式类型转换；  
显式类型转换。

而对于隐式变换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。

**在标准C++中有四个类型转换符：static\_cast、dynamic\_cast、const\_cast和reinterpret\_cast；下面将对它们一一的进行总结。**

##### 1. static\_cast #####

static\_cast的转换格式：static\_cast (expression)

将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

1.  用于类层次结构中，基类和子类之间指针和引用的转换；  
    当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；  
    当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
2.  用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
3.  把void指针转换成目标类型的指针，是及其不安全的；  
    注：static\_cast不能转换掉expression的const、volatile和\_\_unaligned属性。

//隐式的类型转换
    int firstnumber=10;
    double result=(double)firstnumber/secondnumber;
    
    //使用static_dynamic
    double result=static_cast<double> (firstnumber/secondnumber);

*  举个例子：  
    将int（4字节）显示转换成short(2字节)，用vs调试一下，发现static\_cast的作用就是将高位截断。
    
    ![image][]

再举一个例子，讲short显示转换成int，结果如下图所示。  
short是2个字节，int是4个字节，将short转换成int之后，高位根据符号位补满。

![image][image 1]

so，小结一下static\_cast:

1.  基本数据类型之间的转换，如把int转换成char，把int转换成enum
2.  用于类层次结构中基类和子类之间指针或引用的转换。  
    进行上行转换（把子类的指针或引用转换成基类表示）是安全的；  
    进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。
3.  把void指针转换成目标类型的指针(不安全!!)

##### 2. dynamic\_cast #####

dynamic\_cast的转换格式：dynamic\_cast (expression)

将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void \*；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

dynamic\_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic\_cast和static\_cast的效果是一样的；在进行下行转换时，dynamic\_cast具有类型检查的功能，比static\_cast更安全。在多态类型之间的转换主要使用dynamic\_cast，因为类型提供了运行时信息。下面我将分别在以下的几种场合下进行dynamic\_cast的使用总结：

1.  最简单的上行（xing）转换  
    比如B继承自A，B转换为A，进行上行转换时，是安全的，如下：

#include <iostream>
    using namespace std;
    class A
    {
         // ......
    };
    class B : public A
    {
         // ......
    };
    int main()
    {
         B *pB = new B;
         A *pA = dynamic_cast<A *>(pB); // Safe and will succeed
    }

1.  多重继承之间的上行转换  
    C继承自B，B继承自A，这种多重继承的关系；但是，关系很明确，使用dynamic\_cast进行转换时，也是很简单的：

class A
    {
         // ......
    };
    class B : public A
    {
         // ......
    };
    class C : public B
    {
         // ......
    };
    int main()
    {
         C *pC = new C;
         B *pB = dynamic_cast<B *>(pC); // OK
         A *pA = dynamic_cast<A *>(pC); // OK
    }

而上述的转换，static\_cast和dynamic\_cast具有同样的效果。而这种上行转换，也被称为隐式转换；比如我们在定义变量时经常这么写：B \*pB = new C;这和上面是一个道理的，只是多加了一个dynamic\_cast转换符而已。

1.  （**这个真的是重点**）如果expression是type-id的基类，使用dynamic\_cast进行转换时，在运行时就会检查expression是否真正的指向一个type-id类型的对象，如果是，则能进行正确的转换，获得对应的值；否则返回NULL，如果是引用，则在运行时就会抛出异常；例如：

class B
    {
         virtual void f(){};
    };
    class D : public B
    {
         virtual void f(){};
    };
    void main()
    {
         B* pb = new D;   // unclear but ok
         B* pb2 = new B;
         D* pd = dynamic_cast<D*>(pb);   // ok: pb actually points to a D
         D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D, now pd2 is NULL
    }

这个就是**下行转换，从基类指针转换到派生类指针。**

在《More effective C++》里面看见一个很好的例子，也补充在这里

//定义
    class Widget{};
    class SpecialWidget:public Widget{};
    void update(SpecialWidget  *psw);
    
    Widget * pw;
    ...
    
    //如果pw所指的是SpecialWidget ，那么就传递过去；如果pw指的是Widget ，
    //那么传递过去的值是null
    update(dynamic_cast<SpecialWidget  *> (pw));

1.  对于一些复杂的继承关系来说，使用dynamic\_cast进行转换是存在一些陷阱的；比如，有如下的一个结构：
    
    ![image][image 2]

D类型可以安全的转换成B和C类型，但是D类型要是直接转换成A类型呢？

class A
    {
         virtual void Func() = 0;
    };
    class B : public A
    {
         void Func(){};
    };
    class C : public A
    {
         void Func(){};
    };
    class D : public B, public C
    {
         void Func(){}
    };
    int main()
    {
         D *pD = new D;
         A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL
    }

如果进行上面的直接转，你将会得到一个NULL的pA指针；这是因为，B和C都继承了A，并且都实现了虚函数Func，导致在进行转换时，无法进行抉择应该向哪个A进行转换。正确的做法是：

int main()
    {
         D *pD = new D;
         B *pB = dynamic_cast<B *>(pD);
         A *pA = dynamic_cast<A *>(pB);
    }

这就是我在实现QueryInterface时，得到IUnknown的指针时，使用的是\*ppv = static\_cast<IX *>(this);而不是*ppv = static\_cast<IUnknown \*>(this);

对于多重继承的情况，从派生类往父类的父类进行转时，需要特别注意；比如有下面这种情况：

![image][image 3]

> 现在，你拥有一个A类型的指针，它指向E实例，如何获得B类型的指针，指向E实例呢？如果直接进行转的话，就会出现编译器出现分歧，不知道是走E->C->B，还是走E->D->B。对于这种情况，我们就必须先将A类型的指针进行下行转换，获得E类型的指针，然后，在指定一条正确的路线进行上行转换。

上面就是对于dynamic\_cast转换的一些细节知识点，特别是对于多重继承的情况，很容易出现问题。

如何你是好奇宝宝，想知道dynamic\_cast是如何实现的？

侯捷在《内存与对象》书里面做了一个详细的解释，我试着理解了一下。给一个blog ： [http://blog.csdn.net/bitboss/article/details/53574236][http_blog.csdn.net_bitboss_article_details_53574236]

##### 3. const\_cast #####

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

const\_cast的作用是用来改变表达式里面的常量性（const）或易变性（volatile）。

#include <iostream>
    
    using std::cout;
    using std::endl;
    
    int main(void)
    {
        const int b = 10;
        //b = 11 报错，因为b是一个常量对象
        int * pc = const_cast<int *>(&b);
        *pc = 11;
        cout << "*pc = " << *pc << endl;//b原来地址的数据现在可由*pc来改变，即解除const
        cout << "b = " << b << endl; //b其实类似(编译器处理问题)#define b 10 不会变的
    
        return 0;
    }

##### 4. reinterpret\_cast #####

reinterpret\_cast是为了映射到一个完全不同类型的意思，这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的，这是所有映射中最危险的。(这句话是C++编程思想中的原话)

static\_cast 和 reinterpret\_cast操作符修改了操作数类型。它们不是互逆的； static\_cast 在编译时使用类型信息执行转换，在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的。另一方面；reinterpret\_cast仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换， 例子如下：

int n=9; 
    double d=static_cast < double > (n);

上面的例子中, 我们将一个变量从 int 转换到 double。 这些类型的二进制表达式是不同的。 要将整数9转换到 双精度整数9，static\_cast 需要正确地为双精度整数 d补足比特位。其结果为9.0。而reinterpret\_cast 的行为却不同:

int n=9;
    double d=reinterpret_cast<double & > (n);

这次, 结果有所不同. 在进行计算以后,d包含无用值. 这是因为 reinterpret\_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.

因此, 你需要谨慎使用 reinterpret\_cast。

# 其他文章 #

0. **免费帮忙下载csdn和百度文库资料福利**

1. **学习笔记和学习资料汇总：前端 + 后端 + java + 大数据 + python + 100多实战项目 + C++**

2. **我的秋招经历总结：一站式秋招规划**

3. **[零基础学爬虫][Link 1]**

4. **[零基础C++学习总结][C]**

欢迎关注个人公众号【**菜鸟名企梦**】，公众号专注：**互联网求职面经**、**java**、**python**、**爬虫**、**大数据**等技术分享：

公众号**菜鸟名企梦**后台发送“**csdn**”即可免费领取【csdn】和【百度文库】下载服务；

公众号**菜鸟名企梦**后台发送“**资料**”:即可领取**5T精品学习资料**、**java面试考点**和**java面经总结**，以及**几十个java、大数据项目**，资料很全，你想找的几乎都有

![扫码关注，及时获取更多精彩内容。（博主985、A+学科硕士，今日头条大数据工程师）][985_A]

[image]: /images/20230209/9c4f644425b7499f942b140812ffd2b6.png
[image 1]: /images/20230209/1b0f99c919d244c6b5c7c7d325850f45.png
[image 2]: /images/20230209/6fe992a9601b408aa0801f226e061585.png
[image 3]: /images/20230209/9e628242dee74fd588e62971455fd25f.png
[http_blog.csdn.net_bitboss_article_details_53574236]: https://link.jianshu.com?t=http%3A%2F%2Fblog.csdn.net%2Fbitboss%2Farticle%2Fdetails%2F53574236
[Link 1]: https://mp.weixin.qq.com/s/Ix0yo_vtPE41QuwW30dHZA
[C]: https://mp.weixin.qq.com/s/VKmOYhbhELXwaelxGy16rw
[985_A]: /images/20230209/80e4d6ef422c4634ac46c021ac57fed1.png