C++ day34类型转换运算符dynamic_cast，const_cast，static_cast，reinterpret_cast

﹏ヽ暗。殇╰゛Y 2023-02-17 02:56 127阅读 0赞

### 文章目录 ###

*  背景
 *  const\_cast：用于移除变量的const或volatile限定符
 *   *  用通用类型转换（可能会同时改变类型，即不只是修改const）
     *  示例：const\_cast只可以用于自己本身不是const的类型
     *   *  再加一个示例：说明同一个问题
 *  static\_cast(可以向下转换downcast)
 *  dynamic\_cast：只可用于有虚函数的类；只可以转指针或引用；
 *  reinterpret\_cast（用于各种危险的类型转换，尽量少用）
 *  总结

# 背景 #

![在这里插入图片描述][20200611195420245.png]

看几个C语言允许的类型转换示例：  
![在这里插入图片描述][20200611203103493.png]  
![在这里插入图片描述][20200611203111377.png]

C++的创始人看不下去这种没有意义的类型转换，更不能容忍他们在C语言中竟然被接受。。。他觉得C语言太宽松了。于是，他提出要**更严格地限制允许的类型转换**，**把类型转换规范化**，于是添加了4个类型转换运算符。

这四个运算符，相比于通用类型转换，更加明确，更加**安全**。

# const\_cast：用于移除变量的const或volatile限定符 #

对volatile限定符的移除不了解，不说。

只可以移除const，即把const转为非const,不可以把非const转为const

const_cast <type_name> (expression)//type_name和expression的类型必须相同

> 原来非const可以直接称呼为volatile，我以前还一直称呼为非const 。  
> 这个理解对吗？？？

示例：

High bar;
    const High * pbar = &bar;
    High * pb = const_cast<High *> (pbar);//const High *->High *,删除const标签

如果还想做别的，const\_cast就做不到了，它只能改变值为const或volatile。

const Low * pl = const_cast<const Low *>(pbar);//无效，因为pbar是High *，这个操作想要把pbar转换为const，同时还要转换为Low *

## 用通用类型转换（可能会同时改变类型，即不只是修改const） ##

High bar;
    const High * pbar = &bar;
    High * pb = (High *) (pbar);//const High * -> High * 
    Low * pl = (Low *) (pbar); //const High * -> Low * ,不只修改了const,还改了类型

正是这种同时改变类型的操作，很危险，所以尽量使用const\_cast运算符

## 示例：const\_cast只可以用于自己本身不是const的类型 ##

//const_cast.cpp
    #include <iostream>
    using std::cout;
    using std::endl;
    void change(const int * pt, int n);
    
    int main()
    { 
    	int pop1 = 38383;
    	const int pop2 = 2000;
    	cout << "pop1, pop2: " << pop1 << ", " << pop2 << endl;
    	change(&pop1, -100);
    	change(&pop2, -100);
    	cout << "pop1, pop2:" << pop1 << ", " << pop2 << endl;
    	return 0;
    }
    void change(const int * pt, int n)
    { 
    	int * pc;
    	pc = const_cast<int *>(pt);//pc是int *
    	*pc += n;//传入的值加上n
    }

可以看到，第一个值pop1成功被修改了，但是pop2却没有被修改。这是因为，pop1本身不是const的，传入change函数后，成为了const形参

相当于是，const\_cast通过这种方式打破了形参的const的保护，把原本是非const的数值还是成功修改了。但是如果数据本身就是货真价实的非const，即不允许改变的 ,则const\_cast不会再造作，而是会很配合编译器，不允许转换为非const的，所以const\_cast是有一个识别判断规则的，不是傻乎乎转，而要看看到底能不能转，转了安不安全，如果不安全，比如人家本来就是const的，他就不会把人家转为非const的，它不会同意这种不安全的转换。

pop1, pop2: 38383, 2000
    pop1, pop2:38283, 2000

这个示例展示了const\_cast的真正的用武之地：本身不是const的变量传给了一个形参设置为const引用类型的函数，这时候可以在函数内部用const\_cast实现对原变量的修改。除此之外，其实用处好像很少，毕竟我们已经证明，不可能通过const\_cast修改真正的const变量的值。

### 再加一个示例：说明同一个问题 ###

int main()
    { 
       const int a = 10;
       int * b = &a;//C,C++的所有标准都报错
       cout << a << endl;
       *b = 20;
       cout << a << endl;
        return 0;
    }

下面的代码编译可以通过，但是a的值不会被改变，所以非常安全

int main()
    { 
       const int a = 10;
       cout << a << endl;
       int * c = const_cast<int *> (&a);
       *c = 20;
       cout << a << endl;
        return 0;
    }

这个示例说明，C++里面，const就是const,你不管什么招数办法，都改不了const变量的值，所以非常安全。

10
    10

# static\_cast(可以向下转换downcast) #

static\_cast和dynamic\_cast主要是解决类的继承层次中类型转换的安全性。static\_cast是在编译时检查，不再运行时进行类型检查，所以是静态的；而dynamic\_cast是在运行时进行类型检查，所以保证了安全性。

static_cast <type_name> (expression)//type_name和expression的类型必须相同

*  可以向上转换，即把派生类指针或引用转换为基类的指针或引用，这是百分百安全的。
 *  可以向下转换：把基类指针和引用转换为派生类的指针和引用，这99%都是不安全的，因为基类指针指向的对象根本没有派生类的方法和数据，如果你转换后调用派生类的方法，就会出错。static\_cast虽然可以实现向下转换，但是是不安全的。
 *  可以把整型转为枚举变量。
 *  把double转为int，把float转为long等数值转换。  
    示例：

High bar;
    Low blow;//Low是从High继承来的
    High * pb = static_cast<High *> (&blow);//upcast，向上转换
    Low * pl = static_cast<Low *> (&bar);//downcast,向下转换
    Pond * pmer = static_cast<Pond *> (&blow);//无效，因为Pond是无关的类

第一种是派生类转为基类，属于向上转换，可以，用不用static\_cast都行。

其中第二种转换是把`High *`转为`Low *`,基类转为派生类，是向下的转换，如果不用static\_cast，是根本不允许的。

> 向下转换只有用static\_cast才允许。

# dynamic\_cast：只可用于有虚函数的类；只可以转指针或引用； #

用于类层次间的向上和向下转化，static\_cast可以实现类层次的向下转换但是不安全，所以不要用。

上一篇文章说过了。它用来把一种类型的指针转换为另一种类型的指针，**如果可以实现安全转换的话就转**，不能安全转换就不转，而返回一个空指针。

向下转化时，如果是非法的**对于指针返回NULL**，**对于引用抛异常**。要深入了解内部转换的原理。

向上转换：指的是**子类向基类**的转换

向下转换：指的是基类向子类的转换

dynamic_cast <type_name> (expression)

pl = dynamic_cast<Low *> ph;//如果ph可以转换为Low类型的指针，则会把转换得到的Low指针赋给pl,否则赋空指针

那什么叫做能安全转换呢？

在类层次中向上转换（is-a继承关系），就是安全的转换。

# reinterpret\_cast（用于各种危险的类型转换，尽量少用） #

reinterpret_cast <type_name> (expression)//type_name和expression的类型必须相同

*  几乎什么都可以转，比如将int转指针，可能会出问题，尽量少用；相当于是明明可能有错，但是你还是非要转就用这个，当然是尽量不要用了
 *  不允许删除const
 *  但会执行其他令人生厌的操作（有时候程序员必须得做这种依赖于实现的令人生厌的操作）
 *  不支持所有的类型转换
 *  不可以把指针转换为更小的整型和浮点型  
    ![在这里插入图片描述][20200612140945603.png]  
    ![在这里插入图片描述][20200612141028562.png]

但在C语言，这些转换都可以。。所以C++的类型转换限制比C严格很多。

*  不可以把函数指针转换为数据指针，也不可以把数据指针转换为函数指针

# 总结 #

*  C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，**不能进行错误检查**，容易出错。而C++专门提供了这四种类型转换运算符，为的就是提高转换的安全性。
 *  我感觉dynamic\_cast最重要，其次是static\_cast,然后是const\_cast，最后是reintrpret\_cast

[20200611195420245.png]: https://img-blog.csdnimg.cn/20200611195420245.png
[20200611203103493.png]: https://img-blog.csdnimg.cn/20200611203103493.png
[20200611203111377.png]: https://img-blog.csdnimg.cn/20200611203111377.png
[20200612140945603.png]: https://img-blog.csdnimg.cn/20200612140945603.png
[20200612141028562.png]: https://img-blog.csdnimg.cn/20200612141028562.png