C++四种新的类型转换-优快云博客

本文链接：https://blog.youkuaiyun.com/doubleintfloat/article/details/146318792

文章目录

C++ 的四种新类型转换运算符 static_cast、 dynamic_cast、 const_cast 和 reinterpret_cast 是在 C++98 标准中引入的。它们各自有特定的用途和应用场景，相较于传统的强制类型转换（ (type)expression 或 type(expression)）具有更好的类型安全性和可读性。

背景

在早期的 C 语言和 C++ 发展初期，类型转换主要依赖于传统的强制类型转换语法，例如 (type)expression 或者 type(expression)。这种方式虽然简单直接，但缺乏明确的语义区分，容易导致代码的可读性降低，并且可能在不经意间引入难以发现的错误。

C++98 的改进

为了提高类型转换的安全性和代码的可读性，C++98 标准引入了这四种新的类型转换运算符，它们各自具有明确的用途和行为：

static_cast：用于基本数据类型转换、类层次结构中的上行和下行转换等常规转换操作，在编译时进行类型检查。
dynamic_cast：主要用于类层次结构中的安全下行转换，会在运行时进行类型检查，确保转换的安全性。
const_cast：专门用于去除对象的 const 或 volatile 限定符，明确表示这种转换的目的。
reinterpret_cast：用于底层的指针和整数类型之间的转换以及不同类型指针之间的转换，强调这种转换是不考虑类型语义的底层操作。

自从 C++98 引入这些类型转换运算符后，它们就成为了 C++ 编程中进行类型转换的推荐方式，后续的 C++ 标准（如 C++03、C++11、C++14、C++17、C++20 等）也继续保留并支持这些运算符，并且没有对它们的核心功能进行重大修改。

1. `static_cast`

应用场景

基本数据类型转换：用于基本数据类型（如 int、float、double 等）之间的转换，以及枚举类型和整数类型之间的转换。
类层次结构中的上行和下行转换：在类的继承体系中，static_cast 可以用于上行转换（从派生类指针或引用转换为基类指针或引用）和下行转换（从基类指针或引用转换为派生类指针或引用），但下行转换时不进行运行时类型检查。

示例代码

#include <iostream>

// 基本数据类型转换
void basicTypeConversion() {
    int num = 10;
    double d = static_cast<double>(num);
    std::cout << "Converted int to double: " << d << std::endl;
}

// 类层次结构中的转换
class Base {
public:
    virtual void print() { std::cout << "Base" << std::endl; }
};

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

void classHierarchyConversion() {
    Derived derived;
    // 上行转换
    Base* basePtr = static_cast<Base*>(&derived);
    basePtr->print();

    // 下行转换
    Derived* derivedPtr = static_cast<Derived*>(basePtr);
    derivedPtr->print();
}

int main() {
    basicTypeConversion();
    classHierarchyConversion();
    return 0;
}

优点

相比传统强制类型转换，static_cast 具有更好的可读性，能明确表示转换的意图，同时在编译时会进行一些基本的类型检查，减少了因误操作导致的潜在错误。

2. `dynamic_cast`

应用场景

类层次结构中的安全下行转换：主要用于在类的继承体系中进行安全的下行转换，即从基类指针或引用转换为派生类指针或引用。它会在运行时进行类型检查，如果转换不安全（即指针或引用实际上不指向目标派生类对象），对于指针类型会返回 nullptr，对于引用类型会抛出 std::bad_cast 异常。

示例代码

#include <iostream>

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

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

void safeDowncasting() {
    Base* basePtr = new Derived();
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        derivedPtr->print();
    }
    delete basePtr;
}

int main() {
    safeDowncasting();
    return 0;
}

优点

传统强制类型转换在进行下行转换时不会进行运行时类型检查，可能会导致未定义行为。而 dynamic_cast 提供了运行时类型检查，增强了类型转换的安全性。

3. `const_cast`

应用场景

去除 const 或 volatile 限定符：主要用于去除对象的 const 或 volatile 限定符，使得原本不能修改的常量对象或具有 volatile 特性的对象可以被修改。但需要注意的是，这种修改只在特定情况下是合法的，如果原本的对象是真正的常量，修改它会导致未定义行为。

示例代码

#include <iostream>

void removeConst() {
    const int num = 10;
    int* nonConstPtr = const_cast<int*>(&num);
    // *nonConstPtr = 20; // 未定义行为，因为 num 是真正的常量
    int value = 20;
    const int* constPtr = &value;
    int* modifiablePtr = const_cast<int*>(constPtr);
    *modifiablePtr = 30;
    std::cout << "Modified value: " << value << std::endl;
}

int main() {
    removeConst();
    return 0;
}

优点

传统强制类型转换也可以去除 const 限定符，但 const_cast 明确表示了转换的目的是去除 const 或 volatile 限定符，提高了代码的可读性和可维护性，同时让开发者更加明确这种转换的风险。

4. `reinterpret_cast`

应用场景

底层指针和整数类型的转换：用于将指针类型转换为整数类型，或者将整数类型转换为指针类型，还可以进行不同类型指针之间的转换，以及函数指针之间的转换。这种转换是非常底层的，不考虑类型的语义，只是简单地重新解释二进制数据。

示例代码

#include <iostream>

void pointerToInteger() {
    int num = 10;
    int* ptr = &num;
    uintptr_t intValue = reinterpret_cast<uintptr_t>(ptr);
    std::cout << "Pointer converted to integer: " << intValue << std::endl;
    int* newPtr = reinterpret_cast<int*>(intValue);
    std::cout << "Value through new pointer: " << *newPtr << std::endl;
}

int main() {
    pointerToInteger();
    return 0;
}