C++强制类型转换及代码示例

C++中的强制类型转换（type casting）包括 static_cast、dynamic_cast、const_cast 和 reinterpret_cast，它们在用途和行为上有所不同。作为C++程序员，需要了解它们之间的区别、适用场景以及使用时需要注意的事项。下面详细介绍每种强制类型转换，提供代码示例并解释输出结果。

1. static_cast

用途和特点：

• 用于基本数据类型之间的转换。
• 用于类层次结构中的向上和向下转换（基类和派生类之间）。
• 在编译时进行类型检查。
• 安全性高，但不能用于多态类型的向下转换。

代码示例：

#include <iostream>
using namespace std;

class Base 
{
public:
    virtual void show() 
    {
        cout << "Base class\n";
    }
};

class Derived : public Base 
{
public:
    void show() override 
    {
        cout << "Derived class\n";
    }
};

int main() 
{
    Base *basePtr = new Derived();
    Derived *derivedPtr = static_cast<Derived*>(basePtr);

    derivedPtr->show();

    delete basePtr;
    return 0;
}

解释和输出：

• basePtr 指向 Derived 对象，但类型是 Base*。
• static_cast 将 basePtr 转换为 Derived*，成功，因为实际对象是 Derived。
• 调用 derivedPtr->show() 输出 Derived class。

输出：

Derived class

2. dynamic_cast

用途和特点：

• 用于多态类型的向下转换（基类指针或引用转换为派生类指针或引用）。
• 在运行时进行类型检查。
• 需要基类中至少有一个虚函数。
• 如果转换失败，返回 nullptr（指针）或抛出 std::bad_cast 异常（引用）。

代码示例：

#include <iostream>
using namespace std;

class Base 
{
public:
    virtual void show() 
    {
        cout << "Base class\n";
    }
};

class Derived : public Base 
{
public:
    void show() override 
    {
        cout << "Derived class\n";
    }
};

class Unrelated {};

int main() 
{
    Base *basePtr = new Derived();
    Derived *derivedPtr = dynamic_cast<Derived*>(basePtr);

    if (derivedPtr) 
    {
        derivedPtr->show();
    } 
    else 
    {
        cout << "dynamic_cast failed\n";
    }

    Base *unrelatedPtr = new Base();
    Derived *failedCast = dynamic_cast<Derived*>(unrelatedPtr);

    if (failedCast) 
    {
        failedCast->show();
    } 
    else 
    {
        cout << "dynamic_cast failed\n";
    }

    delete basePtr;
    delete unrelatedPtr;
    return 0;
}

解释和输出：

• 第一次转换成功，derivedPtr->show() 输出 Derived class。
• 第二次转换失败，failedCast 为 nullptr，输出 dynamic_cast failed。

输出：

Derived class
dynamic_cast failed

3. const_cast

用途和特点：

• 用于修改对象的 const 或 volatile 属性。
• 可将 const 指针或引用转换为非 const。
• 用于去除 const 限制以便修改对象。

代码示例：

#include <iostream>
using namespace std;

void modify(int &n) 
{
    n = 10;
}

int main() 
{
    const int x = 5;
    cout << "Before const_cast: " << x << endl;

    int &y = const_cast<int&>(x);
    modify(y);

    cout << "After const_cast: " << x << endl;

    return 0;
}

解释和输出：

• x 是 const int。
• const_cast 将 x 转换为非 const 引用 y。
• modify(y) 修改 y 的值。
• 修改 const 对象是未定义行为，可能输出不同结果。

输出（未定义行为，可能不同）：

Before const_cast: 5
After const_cast: 10

4. reinterpret_cast

用途和特点：

• 用于执行几乎任意的指针类型转换。
• 改变指针的类型而不改变实际的比特模式。
• 没有类型检查，非常危险，容易导致未定义行为。
• 主要用于低级别编程，如与硬件接口或处理特定内存布局。

代码示例：

#include <iostream>
using namespace std;

struct Data 
{
    int x;
    float y;
};

int main() 
{
    int n = 42;
    Data *dataPtr = reinterpret_cast<Data*>(&n);

    cout << "Data x: " << dataPtr->x << endl;
    cout << "Data y: " << dataPtr->y << endl;

    return 0;
}

解释和输出：

• n 是 int，其地址被解释为 Data*。
• dataPtr->x 可能等于 n 的值，但 dataPtr->y 的值是不确定的。

输出（未定义行为，可能不同）：

Data x: 42
Data y: (undefined behavior, may vary)

总结

• static_cast: 安全的编译时类型转换，适用于相关类型之间的转换。
• dynamic_cast: 运行时类型转换，适用于多态类型，带有类型检查。
• const_cast: 去除或添加 const 属性，修改 const 对象需要谨慎。
• reinterpret_cast: 任意类型指针转换，没有类型检查，使用需特别小心。

每种类型转换都有特定的使用场景和注意事项。选择合适的类型转换可以提高代码的安全性和可维护性。