理解C++强制类型转换

强制类型转换是有一定风险的，有的转换并不一定安全，如把整型数值 转换成指针 ，把基类指针 转换成派生类指针 ，把一种函数指针 转换成另一种函数指针 ，把常量指针 转换成非常量指针等。

C语言强制类型转换缺点:

主要是为了克服C语言强制类型转换的以下三个缺点。

• 没有从形式上体现转换功能和风险的不同。

例如，将int 强制转换成 double 是没有风险的，而将常量指针转换成非常量指针，将基类指针转换成派生类指针都是高风险的，而且后两者带来的风险不同(即可能引发不同种类的错误)，C语言的强制类型转换形式对这些不同并不加以区分

• 将多态基类指针转换成派生类指针时不检查安全性，即无法判断转换后的指针是否确实指向一个派生类对象。

• 难以在程序中寻找到底什么地方进行了强制类型转换强制类型转换是引发程序运行时错误的一个原因，因此在程序出错时，可能就会想到是不是有哪些强制类型转换出了问题。

  文章目录

  • 强制转换运算符
  • [1 static_cast](#1 static_cast)
  • • [1.1. static_cast用于内置数据类型之间的转换](#1.1. static_cast用于内置数据类型之间的转换)
    • [1.2 用于指针之间的转换](#1.2 用于指针之间的转换)
  • [2. const_cast](#2. const_cast)
  • 3.reinterpret_cast
  • 4.dynamic_cast

强制转换运算符

C++ 引入了四种功能不同的强制类型转换运算符以进行强制类型转换

• static cast
• const cast
• reinterpret_cast
• dynamic_cast

语法：

static_cast<目标类型>(表达式);

const_cast<目标类型>(表达式);

reinterpret_cast<目标类型>(表达式);

dynamic_cast<目标类型>(表达式);

1 static_cast

C风格的类型转换很容易理解：

语法：(目标类型)表达式或目标类型(表达式);

C++认为C风格的类型转换过于松散，可能会带来隐患，不够安全。

C++推出了新的类型转换来替代C风格的类型转换，采用更严格的语法检查，降低使用风险。

C++新增了四个关键字static_cast、const_cast、reinterpret_cast和dynamic_cast，用于支持C++风格的类型转换。

C++的类型转换只是语法上的解释，本质上与C风格的类型转换没什么不同，C语言做不到事情的C++也做不到。

1.1. static_cast用于内置数据类型之间的转换

除了语法不同，C和C++没有区别。

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    int ii = 3;
    long ll = ii;                     // 绝对安全，可以隐式转换，不会出现警告。

    double dd = 1.23;
    long ll1 = dd;                  // 可以隐式转换，但是，会出现可能丢失数据的警告。
    long ll2 = (long)dd;              // C风格：显式转换，不会出现警告。
    long ll3 = static_cast<long>(dd);    // C++风格：显式转换，不会出现警告。
    cout << "ll1=" << ll1 << ",ll2=" << ll2 << ",ll3=" << ll3 << endl;
}

1.2 用于指针之间的转换

C风格可以把不同类型的指针进行转换。

C++不可以，需要借助void *。

#include <iostream>
using namespace std;

void func(void* ptr) {   // 其它类型指针 -> void *指针 -> 其它类型指针
    double* pp = static_cast<double*>(ptr);
}

int main(int argc, char* argv[])
{
    int ii = 10;

    //double* pd1 = &ii;                      // 错误，不能隐式转换。
    double* pd2 = (double*) &ii;      // C风格，强制转换。
    //double* pd3 = static_cast<double*>(&ii);    // 错误，static_cast不支持不同类型指针的转换。

    void* pv = &ii;                               // 任何类型的指针都可以隐式转换成void*。
    double* pd4 = static_cast<double*>(pv);  // static_cast可以把void *转换成其它类型的指针。
    func(&ii);
}

2. const_cast

static_cast不能丢掉指针（引用）的const和volitale属性，const_cast可以。

示例：

#include <iostream>
using namespace std;

void func(int *ii)
{}

int main(int argc, char* argv[])
{
	const int *aa=nullptr;
	int *bb = (int *)aa;                          // C风格，强制转换，丢掉const限定符。
	int* cc = const_cast<int*>(aa);      // C++风格，强制转换，丢掉const限定符。

	func(const_cast<int *>(aa));
}

3.reinterpret_cast

static_cast不能用于转换不同类型的指针（引用）（不考虑有继承关系的情况），reinterpret_cast可以。

reinterpret_cast的意思是重新解释，能够将一种对象类型转换为另一种，不管它们是否有关系。

语法：reinterpret_cast<目标类型>(表达式);

<目标类型>和(表达式)中必须有一个是指针（引用）类型。

reinterpret_cast不能丢掉(表达式)的const或volitale属性。

应用场景：

1）reinterpret_cast的第一种用途是改变指针（引用）的类型。

2）reinterpret_cast的第二种用途是将指针（引用）转换成整型变量。整型与指针占用的字节数必须一致，否则会出现警告，转换可能损失精度。

3）reinterpret_cast的第三种用途是将一个整型变量转换成指针（引用）。

示例：

#include <iostream>
using namespace std;

void func(void* ptr) {  
    long long ii = reinterpret_cast<long long>(ptr);
    cout << "ii=" << ii << endl;
}

int main(int argc, char* argv[])
{
    long long ii = 10;

    func(reinterpret_cast<void *>(ii));
}

4.dynamic_cast

动态转换（dynamic_cast）用于基类和派生类之间的转换，但只能在运行时确定类型信息，因此只能用于多态类型。如果转换失败，将返回一个null指针。其语法如下：

dynamic_cast<目标类型> (原始类型)

以下是几个具体例子:

1、将一个基类指针强制转换为一个派生类指针:

class Base { virtual void f(){} };
class Derived : public Base { void f(){} };
Base *b = new Derived(); // 基类指针指向派生类对象
Derived *p = dynamic_cast<Derived *>(b); // 将基类指针转换为派生类指针

2、使用 dynamic_cast 对指针进行类型判断：

class Base {};
class Derived : public Base {};

Base* b1 = new Derived();
Derived* d1 = dynamic_cast<Derived*>(b1);
if (d1 != nullptr) {
    // b1 是 Derived 类型的。
}

需要注意的是，如果指向的基类指针并不真正指向派生类，或者目标类型与原始类型之间的类型转换无法完成，dynamic_cast会返回null指针或抛出std::bad_cast异常。因此，在使用dynamic_cast时需要非常小心，确保程序的健壮性和安全性。