C++ —— 类型转换static_cast-优快云博客

本文链接：https://blog.youkuaiyun.com/MaoSiri/article/details/145022741

引言

在C++中，数据类型的转换有两种，一种是C风格，另一种是C++风格。
C++创始人认为C风格的类型转换可能存在隐患，不够安全。所以推出新的类型转换方式来替代C风格的类型转换。本文主要讲述C++风格的数据类型转换。
点击链接：C风格的数据类型转换

`C风格`的类型转换

语法：(target_type) expression或target_type (expression)

示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    float b = float(a);
    // float b = float(a);
    printf("a: %d\n", a); // a: 10
    printf("b: %f\n", b); // b: 10.000000
    printf("b: %.2f\n", b); // b: 10.00
    cout << "a / 3 = " << a / 3 << endl; // a / 3 = 3
    cout << "b / 3 = " << b / 3 << endl; // b / 3 = 3.33333
    printf("b / 3 = %f\n", b / 3); // b / 3 = 3.333333

    return 0;
}

`C++风格`的类型转换

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

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

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

`static_cast<target_type>(expression)`

实际开发中static_cast<target_type>(expression)就可以满足很多使用场景了。

用于内置数据类型之间的转换，示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 2025;
    long b = a; // long的取值比int大 这种转换是绝对安全的
    cout << "a = " << a << ", b = " << b << endl;
    // a = 2025, b = 2025
    double c = 18.486;
    long d1 = c; // 这种转换是不安全的，因为double的精度比long大
    long d2 = (long)c; // C风格转换 这种转换是安全的
    long d3 = static_cast<long>(c); // C++风格转换 这种转换是安全的

    cout << "c = " << c << ", d1 = " << d1 
         << ", d2 = " << d2 << ", d3 = " << d3 << endl;
    // c = 18.486, d1 = 18, d2 = 18, d3 = 18

    return 0;
}

用于指针之间的转换，示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 1;
    // double* pa1 = &a; // 错误，不能将int*转换为double*
    double* pa2 = (double*) &a; // C风格强制类型转换
    // double* pa3 = static_cast<double*>(&a); 
    // 错误，static_cast不支持不同类型的指针转换
    
    void* pa4 = &a; // 正确，void*可以指向任意类型的对象
    // 任何类型的指针都可以隐式转换成void*
    double* pa5 = static_cast<double*>(pa4); // 正确，将void*转换为double*
    cout << "pa2: " << *pa2 << endl;
    cout << "pa5: " << *pa5 << endl;

    return 0;
}

其他类型指针 -> void* 指针 -> 其他类型指针

`const_cast<target_type>(expression)`

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

`reinterpret_cast<target_type>(expression)`

static_cast不能用于转换不同类型的指针（引用）（不考虑有继承关系的情况），reinterpret_cast可以。reinterpret_cast的意思是重新解释，能够将一种对象类型转换为另一种，不管它们是否有关系。
语法：reinterpret_cast<target_type>(expression);
<target_type>和(expression)中必须有一个是指针（引用）类型。
reinterpret_cast不能丢掉(表达式)的const或volitale属性。主要用途有：

改变指针（引用）的类型。
将指针（引用）转换成整型变量。整型与指针占用的字节数必须一致，否则会出现警告，转换可能损失精度。
将一个整型变量转换成指针（引用）。

示例代码如下：

#include <iostream>
using namespace std;

void func(void* ptr) {
    // double* pp = static_cast<double*>(ptr);
    long long n = reinterpret_cast<long long>(ptr);
    cout << "n: " << n << endl;
}

int main() {
    long long a = 999;

    double* pa6 = reinterpret_cast<double*>(&a); // 正确，将int*转换为double*
    cout << "pa6: " << *pa6 << endl;
    func(reinterpret_cast<void*>(a));

    return 0;
}