Modern C++ 类型转换

eaglelau

已于 2023-11-10 07:34:39 修改

阅读量112

点赞数

分类专栏： Development Tools 设计文章标签： c++ 开发语言

于 2023-11-08 15:27:58 首次发布

本文链接：https://blog.csdn.net/eaglelau/article/details/134290707

版权

Development Tools 同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

设计

16 篇文章 0 订阅

订阅专栏

现代C++中的四种CAST - 知乎 (zhihu.com)

C++ 引入了强制类型转换相关的转换函数，这些转换函数可以提供一些静态类型检查或者运行期动态类型检查，来帮助开发者检查代码中的错误类型检查，检查程序中的 BUG。并且通过这些类型转换函数，可以使得代码的语义性更强，表述更清晰，可以提高代码的阅读性和可维护性。

在 C/C++ 中，不同的数据类型之间可以相互转换。无需用户指明如何转换的称为自动类型转换（隐式类型转换），需要用户显式地指明如何转换的称为强制类型转换。

不管是自动类型转换还是强制类型转换，前提必须是编译器知道如何转换，例如，将小数转换为整数会抹掉小数点后面的数字，将 int * 转换为 float * 只是简单地复制指针的值，这些规则都是编译器内置的，我们并没有告诉编译器。

换句话说，如果编译器不知道转换规则就不能转换，使用强制类型也无用，转换会失败。

9.6 转换构造函数：将其它类型转换为当前类的类型 - 知乎 (zhihu.com)

9.7 类型转换函数：将当前类的类型转换为其它类型 - 知乎 (zhihu.com)

9.8 再谈C++转换构造函数和类型转换函数（进阶） - 知乎 (zhihu.com)

9.9 C/C++类型转换的本质 - 知乎 (zhihu.com)

9.10 static_cast、dynamic_cast、const_cast和reinterpret_cast（四种类型转换运算符） - 知乎 (zhihu.com)

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

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

static_cast< target-type >( expression ) static_cast conversion - cppreference.com
const_cast< target-type >( expression ) const_cast conversion - cppreference.com
reinterpret_cast< target-type >( expression )reinterpret_cast conversion - cppreference.com
dynamic_cast< target-type >( expression ) dynamic_cast conversion - cppreference.com

target-type 是要转换成的新类型，expression 是被转换的数据。例如，老式的 C 风格的 double 转 int 的写法为：

double scores = 95.5;
int n = (int)scores;

C++ 新风格的写法为：

double scores = 95.5;
int n = static_cast<int>(scores);

C++ 强制风格类型转换：

C++ 引入了强制类型转换相关的转换函数，这些转换函数可以提供一些静态类型检查或者运行期动态类型检查，来帮助开发者检查代码中的错误类型检查，检查程序中的 BUG。并且通过这些类型转换函数，可以使得代码的语义性更强，表述更清晰，可以提高代码的阅读性和可维护性。

static_cast: static_cast conversion - cppreference.com （编译时类型检查）

Converts between types using a combination of implicit and user-defined conversions.

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

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

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

两个具体类型指针之间的转换，例如 int * 转 double *、Student * 转 int * 等。不同类型的数据存储格式不一样，长度也不一样，用 A 类型的指针指向 B 类型的数据后，会按照 A 类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 B 类型的数据遭到破坏，当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。
int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。

static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说，不能将 const/volatile 类型转换为非 const/volatile 类型。相比较于 C 语言风格引入了一些静态的约束，比如检查const 属性和 voliate 属性。

const int g = 20;
 int *h = static_cast<int*>(&g);

上边示例的转换会导致编译错误，因为 non-const 指针 h 想要指向一个常量。

static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

代码演示（正确和错误用法）：

#include <iostream>
#include <cstdlib>
using namespace std;

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;
}

对于多态的场景，向上转换（up cast ，从派生类转换到基类，指针或者引用）、向下转换（down cast，从基类转换成派生类，指针或者引用）的情况如下：

对于向上转换(up)是安全的；
对于向下(down)转换总是成功的，并且不提供检查。效果和 C 风格的强制类型转换是一样的，需要编程者保证转换的安全性，既被转换的派生类和目标转换类型之间必须是继承派生关系。

const_cast: const_cast conversion - cppreference.com

const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。May be used to cast away (remove) constness or volatility.

#include <iostream>
using namespace std;

int main(){
    const int n = 100;
    int *p = const_cast<int*>(&n);
    *p = 234;
    cout<<"n = "<<n<<endl;
    cout<<"*p = "<<*p<<endl;

    return 0;
}

运行结果：
n = 100
*p = 234

&n 用来获取 n 的地址，它的类型为 const int * ，必须使用 const_cast 转换为 int * 类型后才能赋值给 p (int * 类型)。由于 p 指向了 n，并且 n 占用的是栈内存，有写入权限，所以可以通过 p 修改 n 的值。

有读者可能会问，为什么通过 n 和 *p 输出的值不一样呢？这是因为 C++ 对常量的处理更像是编译时期的 #define，是一个值替换的过程，代码中所有使用 n 的地方在编译期间就被替换成了 100。换句话说，第 8 行代码被修改成了下面的形式：

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

这样以来，即使程序在运行期间修改 n 的值，也不会影响 cout 语句了。

使用 const_cast 进行强制类型转换可以突破 C/C++ 的常数限制，修改常数的值，因此有一定的危险性；但是程序员如果这样做的话，基本上会意识到这个问题，因此也还有一定的安全性。

dynamic_cast: dynamic_cast conversion - cppreference.com （运行时类型检查）

动态类型转换，主要用于面向对象中多态应用场景，用于基类指针和派生类指针或者基类引用和派生类引用的安全转换，提供动态的安全检查。

Safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy.

该函数的作用是用来安全的对类的指针或者引用在继承体系中进行向上（up），向下（down）,和侧面（sideways）进行转换。

解释一下上面的转换的名次，解释如下（基于上图中的示例进行讨论）：

向上转换(upcast)：派生类向基类转换，比如从 B 转换到 A；
向下转换(downcast)：基类向派生类转换，比如从 A 转换到 B；
侧面转换(sideways)：同一继承继承级别的类之间的转换，比如 B 转换成 C。

如果 dynamic_cast 类型转换成功，则该函数会返回目标类型对应的值。如果类型转换失败，对于指针类型，则会返回空指针，对于引用类型则会抛出异常 std::bad_cast（因为有空指针，但是没有空引用的概念）。

dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。dynamic_cast 只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。

RTTI

动态转换中的动态指的是运行期进行动态的转换。该函数的运行依赖于一种 RTTI（run-time type identification，动态类型识别的技术）。通常编译器都会提供一个选项，可以用来开启或者关闭该功能。使用 RTTI 动态类型识别技术，会带来额外的性能消耗。dynamic_cast 来进行类型转换的需要根据虚函数表来判断继承关系（动态多态的实现，就是依托于虚函数表来实现的），这里对虚函数表进行查表的操作，会带来额外的性能损耗（如果用 static_cast 来进行转换，则不会进行运行期的动态检查，不会有这方面的新能损耗。）。

通常编译器 RTTI 功能可以通过编译时的命令参数来进行开启或者关闭，当 RTTI 功能关闭的时候，代码运行的时候，如果执行到 dynamic_cast 相关代码的时候，由于该转换函数依赖于 RTTI 功能，而编译器在编译程序的时候该功能被关闭，此时由于没有 RTTI 相关的信息在编译的时候编译到程序中，这个转换功能将无法完成转换，程序会崩溃，这个一定要注意。

（upcasting）向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。「向上转型时不执行运行期检测」虽然提高了效率，但也留下了安全隐患。
（downcasting）向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。

dynmic_cast 总结：

dynamic_cast是运行时处理的，运行时要进行类型检查，而其他三种都是编译时完成的；
不能用于内置基本数据类型间的强制转换（dynamic_cast 只能转换指针类型和引用类型）；
使用 dynamic_cast 进行转换时，基类中一定要有虚函数，否则编译不通过；
dynamic_cast转换若成功，返回的是指向类的指针或引用；若失败则会返回NULL；
在类的转换时，在类层次间进行上行转换时，dynamic_cast 和 static_cast 的效果是一样的。在进行下行转换时，dynamic_cast 具有类型检查的功能，比 static_cast 更安全。向下转换的成败取决于将要转换的类型，即要强制转换的指针所指向的对象实际类型与将要转换后的类型一定要相同，否则转换失败。

reinterpret_cast: reinterpret_cast conversion - cppreference.com

Converts between types by reinterpreting the underlying bit pattern.

允许将任何指针转换为任何其他指针类型。也允许将任何整数类型转换为任何指针类型以及反向转换。

reinterpret_cast 运算符 | Microsoft Learn

滥用 reinterpret_cast 运算符可能很容易带来风险。除非所需转换本身是低级别的，否则应使用其他强制转换运算符之一。
reinterpret_cast 运算符可用于 char * 到 int * 或 One_class * 到 Unrelated_class * 之类的转换，这本身并不安全。
reinterpret_cast 的结果不能安全地用于除强制转换回其原始类型以外的任何用途。在最好的情况下，其他用途也是不可移植的。
reinterpret_cast 运算符无法强制转换掉 const、volatile 或 __unaligned 特性。

通过对底层字节数据进行重新解释来进行类型转换。值得注意的是，其不能用来处理 cv 属性，如果转换前后的类型中的 cv 属性不一致，则无法进行转换，编译会报错。