Welcome to Torosamy`s blog

Appearance

C++ 类型转换 ​

类型转换是将一个数据类型的值转换为另一个数据类型的值的过程。在 C++ 中，类型转换可以分为隐式转换和显式转换，以及几种特定的显式转换操作符。

隐式转换 ​

隐式转换(Implicit Conversion)是由编译器自动执行的类型转换，通常发生在类型兼容且转换是安全的情况下。

常见场景：

  • 算术类型之间的转换： 例如，int 可以自动转换为 double，float 可以自动转换为 double 等。通常，较小的类型会提升为较大的类型以进行运算，避免精度丢失。
cpp
int intValue = 10;
double doubleValue = intValue; // int 隐式转换为 double
std::cout << doubleValue << std::endl; // 输出 10.0

float floatValue = 3.14f;
double anotherDouble = floatValue + intValue; // float 隐式转换为 double，int 隐式转换为 double
std::cout << anotherDouble << std::endl; // 输出 13.14
  • 派生类指针/引用转换为基类指针/引用 (向上转型 - Upcasting): 这是安全的，因为派生类对象是一个基类对象。
cpp
class Base {};
class Derived : public Base {};

Derived* derivedPtr = new Derived();
Base* basePtr = derivedPtr; // 派生类指针隐式转换为基类指针

Derived& derivedRef = *new Derived();
Base& baseRef = derivedRef; // 派生类引用隐式转换为基类引用

注意事项：

  • 隐式转换可能会导致精度丢失（例如，double 转换为 int）。
  • 有时隐式转换可能不是我们期望的行为，因此需要谨慎使用。

显式转换 ​

显式转换(Explicit Conversion)是由程序员明确指定的类型转换。C++ 提供了几种显式的类型转换操作符，比 C 风格的强制类型转换更加安全和易于识别。

C 风格的强制类型转换 ​

语法：(type)expression 或 type(expression)

C 风格的强制类型转换 (C-style Cast)比较灵活，可以执行很多种转换，但也相对不安全，因为它没有明确的转换意图，可能导致未定义的行为。在 C++ 中，推荐使用更安全的 C++ 类型转换操作符。

cpp
double pi = 3.14159;
int integerPi = (int)pi; // C 风格的强制类型转换
std::cout << integerPi << std::endl; // 输出 3 (精度丢失)

Cpp 类型转换操作符 ​

C++ 提供了四种主要的显式类型转换操作符，它们具有更明确的转换意图和更强的类型安全性

static_cast ​

用于执行编译器认为安全的、相关的类型转换

  • 基本数据类型之间的转换（例如，int 到 double，double 到 int）。
  • 具有继承关系的类型之间的转换（基类指针/引用与派生类指针/引用之间的转换 - 不提供运行时类型检查）。
  • void* 与其他指针类型之间的转换。
  • 在编译时进行类型检查，不提供运行时的类型安全检查。
cpp
double d = 3.14159;
int i = static_cast<int>(d); // double 转换为 int

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

Base* basePtr = new Derived();
Derived* derivedPtr = static_cast<Derived*>(basePtr); // 基类指针转换为派生类指针 (需要程序员保证类型安全)

Derived* anotherDerivedPtr = new Derived();
Base* anotherBasePtr = static_cast<Base*>(anotherDerivedPtr); // 派生类指针转换为基类指针 (向上转型)

void* voidPtr = &i;
int* intPtr = static_cast<int*>(voidPtr); // void* 转换为 int*

dynamic_cast ​

主要用于安全地将基类指针或引用转换为派生类指针或引用 (向下转型 - Downcasting)。它在运行时进行类型检查，以确保转换是有效的。

  • 需要基类中至少包含一个虚函数，这是实现运行时类型检查的关键。
  • 如果转换成功，则返回指向派生类对象的指针或引用。
  • 如果转换失败（即，指针或引用指向的实际对象不是目标派生类类型）
  • 如果指针转换失败，返回 nullptr。
  • 如果引用转换失败，抛出 std::bad_cast 异常。
cpp
#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() {} // 基类需要虚函数才能使用 dynamic_cast
};

class Derived : public Base {
public:
    void derivedFunction() {
        std::cout << "Derived function called." << std::endl;
    }
};

int main() {
    Base* basePtr1 = new Derived();
    Base* basePtr2 = new Base();

    Derived* derivedPtr1 = dynamic_cast<Derived*>(basePtr1);
    if (derivedPtr1) {
        derivedPtr1->derivedFunction(); // 安全调用
    } else {
        std::cout << "dynamic_cast failed for basePtr1." << std::endl;
    }

    Derived* derivedPtr2 = dynamic_cast<Derived*>(basePtr2);
    if (derivedPtr2) {
        derivedPtr2->derivedFunction();
    } else {
        std::cout << "dynamic_cast failed for basePtr2." << std::endl; // 输出此行
    }

    delete basePtr1;
    delete basePtr2;
    return 0;
}

reinterpret_cast ​

执行底层的、不安全的类型转换。它允许将一个指针或引用转换为任何其他指针或引用类型，即使它们之间没有任何逻辑关系。

  • 非常危险，应该谨慎使用。 它绕过了 C++ 的类型系统，可能导致未定义的行为。
  • 通常用于处理与硬件或操作系统的底层交互，或者在不同类型之间进行二进制数据的重新解释。
cpp
int intValue = 10;
int* intPtr = &intValue;
char* charPtr = reinterpret_cast<char*>(intPtr); // 将 int 指针重新解释为 char 指针

std::cout << "Value at charPtr: " << static_cast<int>(*charPtr) << std::endl; // 输出结果取决于系统的字节序

// 注意：这样的转换通常是不安全的，除非您非常清楚自己在做什么。

const_cast ​

用于添加或移除指针或引用的 const 或 volatile 限定符。

  • 是唯一可以改变对象常量性的 C++ 类型转换操作符。
  • 如果原始对象被声明为 const，并且您使用 const_cast 移除了 const 限定符并尝试修改该对象，则行为是未定义的。
  • 通常只在需要与一些不接受 const 参数的旧 C 风格 API 交互时才使用 const_cast。
cpp
const int constantValue = 20;
const int* constPtr = &constantValue;

// int* nonConstPtr = const_cast<int*>(constPtr); // 移除 const 限定符

// *nonConstPtr = 30; // 危险！尝试修改原始声明为 const 的对象，行为未定义

void printValue(int* ptr) {
    std::cout << "Value: " << *ptr << std::endl;
}

int nonConstValue = 40;
const int* anotherConstPtr = &nonConstValue;
printValue(const_cast<int*>(anotherConstPtr)); // 安全：原始对象不是 const 的

dynamic_pointer_cast ​

用于安全地将 std::shared_ptr 从基类类型转换为派生类类型 (向下转型)。

  • 与 dynamic_cast 类似，它在运行时进行类型检查，并且需要基类包含虚函数。
  • 如果转换成功，则返回一个新的指向派生类对象的 std::shared_ptr。
  • 如果转换失败，则返回一个空的 std::shared_ptr (即 nullptr)。
cpp
#include <iostream>
#include <memory>

class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void derivedFunction() {
        std::cout << "Derived function called." << std::endl;
    }
};

int main() {
    std::shared_ptr<Base> baseSharedPtr1 = std::make_shared<Derived>();
    std::shared_ptr<Base> baseSharedPtr2 = std::make_shared<Base>();

    std::shared_ptr<Derived> derivedSharedPtr1 = std::dynamic_pointer_cast<Derived>(baseSharedPtr1);
    if (derivedSharedPtr1) {
        derivedSharedPtr1->derivedFunction();
    } else {
        std::cout << "dynamic_pointer_cast failed for baseSharedPtr1." << std::endl;
    }

    std::shared_ptr<Derived> derivedSharedPtr2 = std::dynamic_pointer_cast<Derived>(baseSharedPtr2);
    if (derivedSharedPtr2) {
        derivedSharedPtr2->derivedFunction();
    } else {
        std::cout << "dynamic_pointer_cast failed for baseSharedPtr2." << std::endl; // 输出此行
    }

    return 0;
}

最佳实践 ​

  • 尽可能避免使用 C 风格的强制类型转换。
  • 使用 static_cast 进行编译器认为安全的、相关的类型转换。
  • 使用 dynamic_cast 进行安全的向下转型，确保操作的是实际的派生类对象。
  • 极其谨慎地使用 reinterpret_cast，只在确实需要进行底层数据重新解释时使用。
  • 避免使用 const_cast 修改真正声明为 const 的对象。
  • 使用 dynamic_pointer_cast 安全地转换智能指针。