04 C++中的四种强制类型转换

系列文章目录

04 C++中的四种强制类型转换

---

目录

系列文章目录

文章目录

前言

一、静态转换（Static Cast）

二、动态转换（Dynamic Cast）

三、常量转换（Const Cast）

四、重新解释转换（Reinterpret Cast）

总结

---

前言

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。

隐式类型转换是编译器自动隐式进行的，需要在代码中体现，而显示类型转换由程序员明确指定。

C++支持C风格的强制转换，但是C风格的强制转换可能带来一些隐患，让一些问题难以发现。

所以C++提供了一组适用于不同场景的强制转换的函数：

• static_cast
• dynamic_cast
• const_cast
• reinterpret_cast

下面对这四种转换操作的适用场景分别进行说明。

---

一、静态转换（Static Cast）

静态转换是将一种数据类型的值强制转换为另一种数据类型的值。

静态转换通常用于比较类型相似的对象之间的转换，例如将 int 类型转换为 float 类型。

静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。

下面是一个例子，将int类型转换为float类型：

int main()
{
    int a = 10;
    float b = static_cast<float>(a); // 静态将int类型转换为float类型
    cout << typeid (a).name() << endl;
    cout << typeid (b).name() << endl;
    
}

输出结果为：

int
float

需要注意的是，这里，即使我们写int a = 'a';程序也可以编译过去，所以我们要注意使用。 

 

二、动态转换（Dynamic Cast）

C++中的动态转换（dynamic_cast）是一种类型转换运算符，用于在运行时将指向父类的指针或引用转换为指向其派生类的指针或引用。

使用动态转换时，必须满足以下两个条件之一：

1. 目标类型是源类型的公共派生类。
2. 源类型是指向目标类型的指针或引用。

如果以上条件不满足，则转换将失败并返回空指针或引用。

下面是一个示例：

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout << "Unknown animal sound." << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() {
        cout << "Meow!" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() {
        cout << "Woof!" << endl;
    }
};

int main() {
    // 两个指针变量 a 和 b 分别指向一个 Cat 类型对象和一个 Dog 类型对象。
    Animal* a = new Cat;
    Animal* b = new Dog;

    // 使用动态类型转换将指针 a 转换为指向 Cat 类型的指针 c。
    Cat* c = dynamic_cast<Cat*>(a);

    // 判断指针 c 是否为 nullptr，如果不是，则调用 Cat 类的成员函数 makeSound() 输出动物的叫声；
    // 否则输出 “Cannot convert Animal* to Cat*.”。
    if (c) {
        c->makeSound();
    }
    else {
        cout << "Cannot convert Animal* to Cat*." << endl;
    }

    // 使用动态类型转换将指针 b 转换为指向 Cat 类型的指针 c。
    c = dynamic_cast<Cat*>(b);
    if (c) {
        c->makeSound();
    }
    else {
        cout << "Cannot convert Animal* to Cat*." << endl;
    }

    return 0;
}

输出结果为：

Meow!
Cannot convert Animal* to Cat*.

 在此示例中，我们创建了两个Animal类型的指针，一个指向Cat对象，另一个指向Dog对象。接下来，我们使用Dynamic Cast将这些指针转换为指向Cat对象的指针。第一个转换将成功，因为指针a指向的是Cat对象。第二个转换失败，因为指针b指向的是Dog对象，无法转换为Cat对象。

注意：动态转换在代码中经常用于将基类对象转换为派生类对象，以便使用派生类的成员函数和成员变量。需要注意的是，使用动态转换时应该注意类型安全，并避免滥用。

三、常量转换（Const Cast）

常量转换用于将 const 类型的对象转换为非 const 类型的对象。

常量转换只能用于转换掉 const 属性，不能改变对象的类型

下面是一个常量转换（const_cast）的代码示例：

#include <iostream>
using namespace std;

void printValue(int value) {
    cout << "The value is: " << value << endl;
}

int main() {
    const int value = 10;
    const int* ptr = &value;
    
    // 将 ptr 转换为非常量指针
    int* mutablePtr = const_cast<int*>(ptr);
    
    // 修改指针所指向的值
    *mutablePtr = 20;
    
    // 调用函数输出修改后的值
    printValue(value);
    
    return 0;
}

在这个示例中，我们首先定义了一个常量值 value 和一个指向该值的常量指针 ptr。然后，我们使用 const_cast 将 ptr 转换为非常量指针 mutablePtr。接着，我们通过 mutablePtr 修改了指针所指向的值为 20。最后，我们调用函数 printValue 输出修改后的值，即 20。

需要注意的是，这里的常量指针指向的值并没有真正变为可修改的，只是通过 const_cast 绕过了编译器的常量性检查。因此，使用 const_cast 必须非常小心，避免对常量值进行意外的修改。

四、重新解释转换（Reinterpret Cast）

C++中的重新解释转换（Reinterpret Cast）是一种类型转换操作，用于将一个指针或引用转换为另一种不同类型的指针或引用，而不考虑它的原始类型和值。它主要用于将一个对象的位模式重新解释为另一个对象的位模式。由于这种类型转换没有进行类型检查，因此使用起来比较危险，应该谨慎使用。

以下是一个重新解释转换（reinterpret_cast）的代码：

#include <iostream>
using namespace std;

int main() {
    int num = 100;
    double* pDouble = reinterpret_cast<double*>(&num);

    cout << "num = " << num << endl;
    cout << "pDouble = " << *pDouble << endl;

    return 0;
}

在这个例子中，我们将一个整数类型的变量num的地址，强制类型转换为了双精度浮点数类型的指针。这个强制类型转换的意义是告诉编译器将num的二进制数据按照双精度浮点数类型的格式重新解释。

当我们输出pDouble的值时，由于在编译器中整数和浮点数的存储方式一般是不同的，因此pDouble的值很可能会是随机垃圾数据。

因此，我们在实际开发中很少使用reinterpret_cast，除非我们确实需要进行一些非常特殊的操作。

---

总结

综上，在使用强制类型转换时，需要首先考虑清楚使用目的：

• static_cast：基本类型转换，低风险；
• dynamic_cast：类层次间的上行转换或下行转换，低风险；
• const_cast：去 const 属性，低风险；
• reinterpret_cast：转换不相关的类型，高风险。