C++：四大强制类型转换

文章目录

• 概述
• • [1. `静态转换 static_cast<T>()`](#1. 静态转换 static_cast<T>())
  • [2. `dynamic_cast<T>()`](#2. dynamic_cast<T>())
  • [3. `const_cast<T>()`](#3. const_cast<T>())
  • [4. `reinterpret_cast<T>()`](#4. reinterpret_cast<T>())

概述

C++ 中有四种强制类型转换，它们分别是：静态转换（static_cast）、const_cast（常量转换）、动态转换（dynamic_cast）、重新解释转换（reinterpret_cast）。

C++ 中有四种强制类型转换，它们是：

1. 静态转换 static_cast<T>()

用于非多态类型之间的转换，用于基本类型之间的转换或在类之间进行显示的转换。例如，从父类指针转换到子类指针，或者转换基本数据类型。

• 在编译时进行类型检查，在运行时并不进行类型检查，因此在使用时要确保转换是安全的，如果类型不兼容，编译时会报错。如果父类指针实际上并不是指向子类的对象，转换结果可能会导致未定义行为。
• 运行时不进行检查：其假设用户知道正在进行的转换，如已经知道父类指针实际指向子类对象。如果父类指针实际上并不是指向子类的对象，转换结果可能会导致未定义行为。
• 常用于已经知道对象的真实类型，如基本类型之间的转换，或父类到子类的转换。

//整数转换为浮点数：
int intValue = 10;
float fv = static_cast<float >(intValue);

//类之间进行显式的转换：
#include <iostream>
class Base {
public:
    virtual ~Base() {} // 基类析构函数需要为虚函数，以便正确销毁派生类对象
    virtual void print() const {
        std::cout << "Base" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() const override {
        std::cout << "Derived" << std::endl;
    }
};

int main() {
    Base base;
    Derived derived;

    // 在基类指针和派生类指针之间进行静态转换
    Base* basePtr = &base;
    Derived* derivedPtr = static_cast<Derived*>(basePtr);

    // 执行转换后，调用派生类的成员函数
    derivedPtr->print(); // 输出 "Derived"

    return 0;
}

2. dynamic_cast<T>()

用于在类层次结构中进行指针或引用的转换，特别是在处理继承关系时。当你进行向下转型（派生类向基类）或向上转型(基类向派生类)时，如果转换不合法，dynamic_cast 会返回 nullptr（对于指针类型），或者抛出 std::bad_cast 异常（对于引用类型）。通常用于多态类型的转换。

• 运行时进行类型检查，特别时在使用多态的情况下；
• 要求基类有虚函数：要求在基类中至少有一个虚函数，以确保有RTTI(运行时类型信息)，因为其依赖运行时类型信息来执行类型转换。
• 当不确定父类指针是否指向子类对象时，dynamic_cast 是更安全的选择，尤其是在多态场景中。

class Base { virtual void foo() {} };
class Derived : public Base {};

Base* base = new Derived();
Derived* derived = dynamic_cast<Derived*>(base);  // 安全地向下转型

Base* base = new Base();
Derived* derived = dynamic_cast<Derived*>(base);  // 运行时检查类型，如果 base 不是 Derived 类型，返回 nullptr
if (derived == nullptr) {
 std::cout << "Conversion failed!" << std::endl;
}

3. const_cast<T>()

用于去除或添加对象的常量性。

• 常用于修改 const 或 volatile 修饰的对象的值。需要小心使用，因为修改 const 对象的内容会导致未定义行为。
• 这种转换通常用于修复传入的函数参数的 const 修饰符，或者在需要时去除 const 修饰符以修改变量。

const int x = 10;
int* y = const_cast<int*>(&x);  // 去除 const 限定符

4. reinterpret_cast<T>()

用于进行低级的类型转换，提供了最不安全的类型转换，允许在不同类型之间进行任意位模式的转换。通常用于将一个指针类型转换成另一个指针类型，或者将整数类型转换为指针类型。它不做任何类型检查，因此使用时需要非常小心，可能会导致未定义行为。

int x = 42;
void* ptr = reinterpret_cast<void*>(&x);  // 将 int* 转换为 void*

这些类型转换各自有不同的应用场景，适用于不同的转换需求。