static_cast 和 reinterpret_cast 简介、用法与错误示例

static_cast 和 reinterpret_cast 简介

static_cast 和 reinterpret_cast 都是 C++ 中的类型转换操作符，但它们的含义和用法有着明显的区别。

static_cast 可以将一个变量从一种类型转换为另一种类型，并且这种转换是安全的。例如把 int 类型转换为 double 类型、将指向基类的指针转换为指向派生类的指针、将一个整型转换为枚举类型等。在这种转换过程中，发生的可能的精度损失或者整型到枚举类型的非法转换等问题都会得到编译器的警告或者报错。因此 static_cast 是比较安全的一种类型转换。

reinterpret_cast 可以让程序员修改一个指针或者变量的类型，通常用于底层的指针和内存操作中。可以把一个指针转换成一个整数，或者把一个整数转换成指针。对于 reinterpret_cast 操作而言，并没有进行任何的类型检查，因此很容易发生由于指针类型不匹配而引发的内存错误，这就要求程序员自己保证转换的正确性。因此 reinterpret_cast 是一种比较危险的类型转换，适用场景非常有限。

以下是 static_cast 和 reinterpret_cast 的基本语法：

new_type = static_cast(expression);    // static_cast 语法

new_type = reinterpret_cast(expression);    // reinterpret_cast 语法

//其中，new_type 表示目标类型，expression 表示要进行转换的表达式。

用法示例

// 1. static_cast 示例
int a = 10;
double b = static_cast(a);    // 将整数类型转换为浮点数类型
std::cout << "b = " << b << std::endl;

// 2. static_cast 示例
class Base {
public:
    virtual void dummy() {}
};

class Derived : public Base {
public:
    void dummy() override {}
};

Base* basePtr = new Derived();
Derived* derivedPtr = static_cast(basePtr);    // 将基类指针转换为派生类指针
derivedPtr->dummy();

// 3. reinterpret_cast 示例
int x = 10;
int* ptr = &x;
void* voidPtr = reinterpret_cast(ptr);    // 将指针转换为 void* 类型
std::cout << "voidPtr = " << static_cast(voidPtr) << std::endl;

// 4. reinterpret_cast 示例
int i = 10;
int* intptr = &i;
double* doubleptr = reinterpret_cast(intptr);    // 将整数指针转换为双精度浮点数指针

在第一个示例中，我们使用 static_cast 将整数类型 int 转换为浮点数类型 double。

第二个示例展示了将基类指针转换为派生类指针。由于在运行时派生类对象包含了基类对象的成员，因此可以通过将基类指针转换为派生类指针来访问派生类对象的成员函数。

在第三个示例中，我们使用 reinterpret_cast 将指针类型转换为 void* 类型。这种转换可以用于将指针传递给某些处理无类型内存的函数。

在第四个示例中，我们使用 reinterpret_cast 将 int 类型的指针转换为 double 类型的指针。这种转换很危险，因为整数指针和双精度浮点数指针的内存布局是不同的。这个示例只是为了演示 reinterpret_cast 的使用，并不是一个常见的用法。

总的来说，static_cast 是比较通用且安全的类型转换，适用于大多数类型转换的场景。而 reinterpret_cast 可能会导致类型不匹配和未定义行为，因此使用时需要谨慎。

reinterpret_cast错误示例1

int x = 10;
int* ptr = &x;
double* doubleptr = reinterpret_cast(ptr);    // 将整数指针转换为双精度浮点数指针
*doubleptr = 3.14;    // 写入一个双精度浮点数

std::cout << x << std::endl;    // 输出 "0"，而不是 "3"

在这个示例中，我们试图将 int 类型指针转换为 double 类型指针，并将一个双精度浮点数写入这个指针指向的内存。这个转换是不安全的，因为 int 和 double 类型在内存布局上通常是不相同的，因此将一个 double 类型的值写入一个 int 类型的变量可能会导致 undefined behavior，即未定义行为。

reinterpret_cast错误示例2

struct A {
    int a;
};

struct B {
    int b;
};

A* aPtr = new A();
aPtr->a = 10;
B* bPtr = reinterpret_cast(aPtr);    // 将 A* 转换为 B*

bPtr->b = 20;    // 在 B* 上使用 B 的成员变量 b

std::cout << aPtr->a << std::endl;    // 输出 "20"，而不是 "10"

在这个示例中，我们将一个 A* 类型的指针转换为 B* 类型的指针，并在 B* 上使用 B 的成员变量 b。由于 A 和 B 结构体的定义是不同的，转换后的指针类型不匹配，因此在使用 bPtr 来访问 b 时，实际上修改了 aPtr 指向的 a 成员变量。

水平有限，欢迎一键三连~