【C++】4种强制类型转换|static_cast|dynamic_cast|reinterpret_cast|const_cast---编辑中

原创已于 2025-03-11 10:29:53 修改 · 1.4k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#c++

于 2020-05-04 12:01:52 首次发布

C/C++ 专栏收录该内容

207 篇文章

订阅专栏

本文详细解析了C++中的四种类型转换操作符：static_cast、dynamic_cast、reinterpret_cast和const_cast，包括它们的用法、特点及应用场景。通过具体示例，展示了如何在类层次结构和基本数据类型间进行安全和非安全的转换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

c语言中的类型转换

C-风格 cast （强制转换）

举例：

 int i;
 double d;
 i = (int) d;

c++中的类型转换

简单说明

在简单的情况下，c语言中类型转换可以很好地工作，但在C++中往往还是不够的，为此ANSI-C++新标准定义的四个转换符，即

static_cast
dynamic_cast
reinterpret_cast
const_cast

它们各自有不同的用途和适用场景：

static_cast
- 用途：用于相关类型之间的转换，比如基本数据类型的转换（如 int 到 double），或在继承层次中进行向上转型（从派生类到基类）。
- 安全性：编译时检查，所以相对安全，如果转换不合理，编译器会报错。
- 限制：不能用于跨越类的继承层次进行向下转换（即从基类指针或引用转换为派生类指针或引用），除非能确保转换是安全的。
dynamic_cast
- 用途：主要用于运行时的(多态类型转换)安全地向下转型（从基类指针或引用转换为派生类指针或引用），它需要 RTTI (Run-Time Type Information) 支持。
- 安全性：运行时检查转换的合法性，如果转换不成功，返回nullptr（对于指针）或抛出std::bad_cast异常（对于引用）。
- 限制：要求运行时类型信息（RTTI）支持，且只能用于含有虚函数的类体系。
reinterpret_cast （/ɪnˈtɜːpˌrɛt/ cast--重解释类型转换）
- 用途：低级别的位模式重新解释转换，几乎不进行任何类型检查或转换。
- 安全性：非常不安全，因为它仅仅改变了类型的解释方式，而不改变数据本身。使用它可能导致未定义行为，除非使用者非常清楚他们在做什么。
- 用途示例：转换任意指针类型为void*，或者将void*转换回原始指针类型，以及在特定硬件或系统编程中进行特定的位操作。
const_cast
- 用途：用于添加或移除const、volatile限定符。
- 安全性：相对安全，但使用它可能会导致原本不可变的数据被修改，从而可能破坏程序的逻辑或稳定性。
- 用途示例：当你有一个指向常量数据的指针或引用，但你需要修改这些数据时（通常这种情况应该避免，除非你有充分的理由相信这样做是安全的）。

总结来说，

static_cast用于编译时的常规类型转换，

dynamic_cast用于运行时的安全多态类型转换，

reinterpret_cast用于低级别的、几乎不进行类型检查的转换，而

const_cast用于修改对象的const或volatile属性。

选择使用哪种类型转换操作符，应基于具体的需求、转换的安全性和代码的可维护性。

区别

static_cast和reinterpret_cast的区别

C++ primer第五章里写了编译器隐式执行任何类型转换都可由static_cast显式完成;reinterpret_cast通常为操作数的位模式提供较低层的重新解释

1、C++中的static_cast执行非多态的转换，用于代替C中通常的转换操作。因此，被做为显式类型转换使用。比如：

int i;
float f = 166.71;
i = static_cast<int>(f);

2、C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。将数据的二进制存在形式的重新解释。比如：此时结果，i的值为166。

int i;
char *p = "This is an example.";
i = reinterpret_cast<int>(p);

此时结果，i与p的值是完全相同的。reinterpret_cast的作用是说将指针p的值以二进制（位模式）的方式被解释为整型，并赋给i，//i 也是指针，整型指针；一个明显的现象是在转换前后没有数位损失。

static_cast和c的强制转换的区别

C++ 的编译器可能会对 reinterpret_cast 进行一些额外的检查，以确保转换的合理性（尽管这种检查通常是有限的）。
C 的强制类型转换则主要依赖于程序员的判断，编译器提供的检查很有限。

reinterpret_cast和c的强制转换的区别

类型安全性：static_cast 提供了更高的类型安全性。它只能用于在类型系统允许的范围内进行转换，例如从派生类到基类的向上转型，或者从具有明确转换关系的基本数据类型之间进行转换。而 C 的强制类型转换则更加灵活（也更加危险），它允许几乎任何类型的转换，即使这些转换在语义上是不合理的。
可读性：static_cast 提供了更好的代码可读性。通过明确指定转换的目标类型，它使得代码更加易于理解和维护。相比之下，C 的强制类型转换可能会使代码更加难以阅读和理解，特别是当转换涉及复杂类型时。
范围：static_cast 可以用于更多的场景，包括基本数据类型之间的转换、类层次结构中的向上和向下转型（尽管向下转型通常是不安全的，需要开发者谨慎使用）、以及移除 const 或 volatile 限定符等。而 C 的强制类型转换则没有这些特定的限制或功能。
错误处理：由于 static_cast 是在编译时进行类型检查的，因此如果转换是不合法的，编译器会立即报错。这有助于在开发阶段早期发现问题并进行修复。而 C 的强制类型转换则可能会在运行时导致未定义行为或程序崩溃等问题。
编译时检查：static_cast 是在编译时进行类型检查的，这意味着如果转换是不安全的或者类型不兼容，编译器会报错。同样，C 的强制类型转换也是在编译时进行的（尽管它不提供像 static_cast 那样的严格类型检查）。

例子

const_cast：

用途：用于添加或移除const、volatile限定符。

例子：

const int originalValue = 10; // 原始值是 const，表示不应该被修改

int* modifiableValue = const_cast<int*>(&originalValue);

*modifiableValue = 42; // 这种做法是未定义行为，因为修改了原本为 const 的变量

注意：使用 const_cast 修改 const 变量是未定义行为，应谨慎使用。

// 使用 const_cast 添加 const 限定符
const int* constPointer = const_cast<const int*>(nonConstPointer);

static_cast：

用途：类型之间的转换，编译时检查。

例子：

double c = 3.14;

int d = static_cast<int>(c); // 将双精度浮点数转换为整数

dynamic_cast：

用途：主要用于运行时的(多态类型转换)安全地向下转型（从基类指针或引用转换为派生类指针或引用），运行时检查。

说明：通常用于将基类指针或引用转换为派生类指针或引用，需要运行时类型信息（RTTI）支持。

例子

class Base {
public:
virtual ~Base() {} // 基类需要至少一个虚函数来启用 RTTI
};

class Derived1 : public Base {
public:
void show() {
std::cout << "I am Derived1" << std::endl;
}
};

void identifyAndShow(Base* basePtr) {
Derived1* d1 = dynamic_cast<Derived1*>(basePtr);
d1->show();

}

Base* b1 = new Derived1();
identifyAndShow(b1); // 输出: I am Derived1

reinterpret_cast：

用途：用于位模式完全不同的类型之间的转换，不进行任何检查，相当于 C 的强制转换。
通常只用于指针类型之间的转换、指针与整数类型之间的转换。

例子：

int e = 65;

char* f = reinterpret_cast<char*>(&e); // 将整数地址转换为字符指针

注意：reinterpret_cast 非常不安全，因为它不进行类型检查，可能导致未定义行为。应谨慎使用，

下面的代码是四种casting方法的典型用法示例：

     #include <iostream>
     using namespace std;
     class Base
     {
     public:
         int _base;
         virtual void printinfo()
         {
              cout << _base << endl;
         }
     };
     class Derived : public Base
     {
     public:
         int _derived;
         virtual void printinfo()
         {
              cout << _derived << endl;
         }
     };
     int main(void)
     {
         Base    b1;
         Derived d1;
         int    aInt    = 10;
         long   aLong   = 11;
         float  aFloat  = 11.11f;
         double aDouble = 12.12;
         Derived* pd = static_cast<Derived*>(&b1);       // down-casting 不安全
         Base*    pb = static_cast<Base*>(&d1);          // up-casting   安全
         Derived& d = static_cast<Derived&>(b1);         // down-casting 不安全
         Base& b = static_cast<Base&>(d1);               // up-casting   安全
         aInt = static_cast<int>(aFloat);                // 基本数据类型转换
         void* sth = static_cast<void*>(&aDouble);       // 将double指针类型转换成void指针类型
         double* bDouble = static_cast<double*>(sth);    // 将void指针类型转换成double指针类型
         cout << *bDouble << endl;
         Base* pb1 = dynamic_cast<Base*>(&d1);
         //Derived* pd1 = dynamic_cast<Derived*>(&b1);   // 编译时有warning，运行时出错
         int bInt = reinterpret_cast<int>(pb1);          // 将地址或指针转换成整数
         cout << bInt << endl;
         pb1 = reinterpret_cast<Base*>(bInt);            // 将整数转换成地址或指针
         int* cInt = reinterpret_cast<int*>(&aFloat);    // 这个转换的结果会出乎意料
         cout << (int)*cInt << endl;
         const Base* bBase = new Base();
         Base* cBase = const_cast<Base*>(bBase);
         //Base* dBase = dynamic_cast<Base*>(bBase);     // 不能通过编译
         //Base* eBase = static_cast<Base*>(bBase);      // 不能通过编译
         //Base* fBase = reinterpret_cast<Base*>(bBase); // 不能通过编译
         return 0;
    }

dynamic_cast 使用示例：


// testCast.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <vector>
using namespace std;

class CAnimal
{
public:
    virtual void eat() 
    {
        cout << "animal eat" << endl;
    }

};

class CDog : public CAnimal
{
public:
    void eat()
    {
        cout << "dog eat" << endl;
    }

    void playBone()
    {
        cout << "dog play bone" << endl;
    }
};

class CCat : public CAnimal
{
public:
    void eat()
    {
        cout << "cat eat" << endl;
    }

    void playBall()
    {
        cout << "cat play ball" << endl;
    }
};

int main()
{
    vector<CAnimal*> vecAnimalList;
    CAnimal* pAnimal = new CDog();
    vecAnimalList.push_back(pAnimal);

    pAnimal = new CDog();
    vecAnimalList.push_back(pAnimal);

    pAnimal = new CCat();
    vecAnimalList.push_back(pAnimal);

    pAnimal = new CCat();
    vecAnimalList.push_back(pAnimal);

    for (int nIdx = 0; nIdx < vecAnimalList.size(); ++nIdx)
    {
        vecAnimalList[nIdx]->eat();

        CDog* pDog = dynamic_cast<CDog*>(vecAnimalList[nIdx]);
        if (nullptr != pDog)
        {
            pDog->playBone();
        }
        else
        {
            CCat* pCat = dynamic_cast<CCat*>(vecAnimalList[nIdx]);
            if (nullptr != pCat)
            {
                pCat->playBall();
            }
            else
            {
                cout << "error type" << endl;
            }
        }
    }



    return 0;
}

C++强制类型转换运算符（static_cast、reinterpret_cast、const_cast和dynamic_cast）