C++ 类型转换

C++ 中的类型转换（Type Casting）是将一个数据类型转换为另一个数据类型的过程。C++ 支持多种类型转换方式，主要分为隐式类型转换和显式类型转换（强制转换）。下面是对几种常见类型转换的介绍：

1. 隐式类型转换（Implicit Type Conversion）

隐式类型转换是编译器自动进行的，通常发生在两种类型兼容的情况下，比如从较小的类型转换为较大的类型。你不需要显式地进行操作，编译器会自动完成这种转换。

#include <iostream>

int main() {
    int a = 42;
    double b = a; // 隐式类型转换：int 转换为 double
    std::cout << "a = " << a << ", b = " << b << std::endl; // 输出：a = 42, b = 42.000000
    return 0;
}
在这个例子中，int 类型的变量 a 自动被转换成 double 类型的变量 b，没有使用显式的类型转换。

2. 显式类型转换（Explicit Type Conversion / Type Casting）

显式类型转换是通过某种操作明确地将一种数据类型转换为另一种数据类型，C++ 提供了四种不同的显式类型转换操作符，分别是：

1. C 风格类型转换

C++ 继承了 C 语言的类型转换方式，使用括号 () 来进行类型转换。这种方式被称为 C 风格的类型转换。它很简单，但可能带来隐式的风险，因为它没有任何安全检查。

语法：(type) expression;

#include <iostream>

int main() {
    double d = 9.7;
    int i = (int)d; // C 风格类型转换
    std::cout << "d = " << d << ", i = " << i << std::endl; // 输出：d = 9.7, i = 9
    return 0;
}

2. static_cast

static_cast 是 C++ 中比较常用的一种类型转换方式。它用于基本类型之间的转换，或者将一个类的指针转换为其基类或派生类的指针（必须保证安全性）。

语法：static_cast<type>(expression);

#include <iostream>

int main() {
    double d = 9.7;
    int i = static_cast<int>(d); // 使用 static_cast 进行类型转换
    std::cout << "d = " << d << ", i = " << i << std::endl; // 输出：d = 9.7, i = 9
    return 0;
}

3. const_cast

const_cast 用于在类型转换时去除或添加 const 属性。它主要用于去除对象的常量性，从而允许修改那些原本声明为 const 的变量。

语法：const_cast<type>(expression);

#include <iostream>

void modify(const int* x) {
    int* non_const_x = const_cast<int*>(x);
    *non_const_x = 10;
}

int main() {
    const int a = 5;
    modify(&a); // 使用 const_cast 进行类型转换
    std::cout << "a = " << a << std::endl; // 输出的值可能不确定，行为未定义
    return 0;
}

const_cast 允许去除 const，但使用时需要非常小心，因为它可能会破坏程序的安全性。

4. dynamic_cast

dynamic_cast 主要用于在类继承体系中进行指针或引用的转换。它确保在多态情况下，安全地将基类指针转换为派生类指针。如果转换失败，指针会返回 nullptr，引用会抛出异常。

语法：dynamic_cast<type>(expression);

#include <iostream>

class Base {
    virtual void func() {} // 必须有虚函数，才能使用 dynamic_cast
};

class Derived : public Base {};

int main() {
    Base* basePtr = new Derived;
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 动态类型转换

    if (derivedPtr) {
        std::cout << "Conversion successful!" << std::endl;
    } else {
        std::cout << "Conversion failed!" << std::endl;
    }

    delete basePtr;
    return 0;
}

5. reinterpret_cast

reinterpret_cast 是一种非常强大的类型转换，它可以在几乎任何类型之间进行转换，但使用时要非常小心，因为它不做任何类型安全检查，可能会导致非常危险的后果。

语法：reinterpret_cast<type>(expression);

#include <iostream>

int main() {
    int a = 65;
    char* charPtr = reinterpret_cast<char*>(&a); // 将 int* 转换为 char*
    std::cout << "Character: " << *charPtr << std::endl; // 输出：A (ASCII 65 的字符)
    return 0;
}

reinterpret_cast 允许在不相关的类型之间进行转换，例如从整数指针到字符指针，但这种转换可能会产生不可预期的行为，尤其是指针的转换。

总结

• 隐式类型转换：由编译器自动完成，适用于兼容类型之间的转换。
• 显式类型转换：
  • C 风格类型转换：简单但危险，没有类型检查。
  • static_cast：用于基本类型转换和类层次结构中的安全转换。
  • const_cast：用于去除或添加 const 属性。
  • dynamic_cast：用于类层次结构中的安全类型转换，通常用于多态类型。
  • reinterpret_cast：强大的类型转换，用于不相关类型之间的转换，但要谨慎使用。