c++ 4种强制类型转换

C++的类型转换符:static_cast、dynamic_cast、reinterpret_cast、和const_cast

形式:class_name <type>(expression) ,其中class_name为以上4种,type是转换的目标类型,expression是要转换的值。

1、static_cast 
任何具有明确定义的类型转换,只要不包含底层const,都可以使用static_const。在编译期强制转换。

顶层const:表示指针本身是个常量。如:int *const p; 
底层const:表示指针所指的对象是一个常量。如:int const *p;

该运算符没有运行时类型检查来保证转换的安全性

①用于类层次结构中基类和子类之间指针或引用的转换。 
进行上行转换(把子类的指针或引用转换成基类表示)是安全的; 
进行下行转换(把基类指针或引用转换成子类表示)时,由于没有动态类型检查,所以是不安全的。

涉及到类,static_cast只能在有相互联系的类型中进行相互转换。

class A
{};
class B:public A
{};
class C
{};

int main()
{
    A* a=new A;
    B* b;
    C* c;
    b=static_cast<B>(a);  // 编译不会报错, B类继承A类
    c=static_cast<B>(a);  // 编译报错, C类与A类没有任何关系
    return 1;
}

②用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。

③把空指针转换成目标类型的空指针。

④把任何类型的表达式转换成void类型。

注意:static_cast不能转换掉expression的const、volitale、或者__unaligned属性。

2、const_cast 
const_cast只能改变运算对象的底层const,用来移除变量的const或volatile限定符。

const char m = 't';  
const char *cm = &m;  
char *n = const_cast<char*>(cm);  
*n = 'a';  
cout << *n << endl; //输出a

但是,const_cast是不能用来执行任何类型的转换的,这样都会引起编译错误的!

const char m = 't';  
const char *cm = &m;  
int *n = const_cast<int*>(cm);  //编译出错,const_cast只能调节类型限定符,不能更改基础类型
*n = 'a';  
cout << *n << endl;  

3、dynamic_cast 
Type必须是类的指针、类的引用或者void *,用于将基类的指针或引用安全地转换成派生类的指针或引用。

注意: 
(1)dynamic_cast在运行期强制转换,运行时要进行类型检查,较安全。 
(2)不能用于内置的基本数据类型的强制转换。

涉及到类,使用dynamic_cast进行转换的,基类中一定要有虚函数,否则编译不通过。

对指针进行dynamic_cast,失败返回null,成功返回正常cast后的对象指针; 
对引用进行dynamic_cast,失败抛出一个异常bad_cast,成功返回正常cast后的对象引用。

对于“向上转换”(即派生类指针或引用转换为其基类类型)都是安全地。 
对于“向下转型”有两种情况: 
第一,基类指针所指对象是派生类类型,这种转换是安全的; 
第二,基类指针所指对象为基类类型,dynamic_cast在运行时做检查,转换失败,返回结果为0。

    #include<iostream>  
    using namespace std;  
    class Base{  
    public:  
      Base(){};  
      virtual void Show(){cout<<"This is Base calss";}  
    };  
    class Derived:public Base{  
    public:  
      Derived(){};  
      void Show(){cout<<"This is Derived class";}  
    };  

    int main(){  
        //这是第一种情况  
        Base* base = new Derived;  
        if(Derived *der= dynamic_cast<Derived*>(base))  {  
            cout<<"第一种情况转换成功"<<endl;  
            der->Show();  
            cout<<endl;  
        }  
        //这是第二种情况  
        Base * base1 = new Base;  
        if(Derived *der1 = dynamic_cast<Derived*>(base1))  {  
            cout<<"第二种情况转换成功"<<endl;  
            der1->Show();  
        }  
        else  {  
            cout<<"第二种情况转换失败"<<endl;  
        }  
        delete(base);  
        delete(base1);  
        return 0;  
    }  

输出:

第一种情况转换成功 
This is Derived class 
第二种情况转换失败

4、reinterpret_cast

在指针之间转换,将一个类型的指针转换为另一个类型的指针,无关类型; 
将指针值转换为一个整型数,但不能用于非指针类型的转换。

    #include<iostream>  
    using namespace std;   
    int main()  {  
        int a=10;  
        int *i=&a;  
        long pc=reinterpret_cast<long>(i);//把一个指针转换为一个整数,即取出地址值  
        char *str=reinterpret_cast<char *>(i);//把int*转换为char *(比int型小),无输出  
        long *l=reinterpret_cast<long *>(i);//把int *转换为long *(比int型大),取出地址值(即i值)输出  

        cout<<*i<<endl;  
        cout<<hex<<pc<<endl;  
        cout<<i<<endl;  
        cout<<"char:"<<str<<endl;  
        cout<<l<<endl;  

        return 0;  
    } 

输出:

10 
28fedc 
0x28fedc 
char: 
0x28fedc

总结: 
去const属性用const_cast 
基本类型转换用static_cast 
多态类之间的类型转换用daynamic_cast 
不同类型的指针类型转换用reinterpreter_cast

<think>我们正在讨论C++中的四种类型转换运算符:static_cast, dynamic_cast, const_cast, reinterpret_cast。用户希望了解它们的使用场景和区别。根据提供的引用,我们可以总结如下: 1. static_cast: 用于基本类型转换、有继承关系的类指针或引用的转换(包括向上转型和向下转型,但向下转型不安全)。 2. dynamic_cast: 主要用于安全的向下转型(需要虚函数支持,即多态类型),转换失败时返回空指针(指针)或抛出异常(引用)。 3. const_cast: 用于移除const或volatile限定符,常用于函数参数传递时去除const属性。 4. reinterpret_cast: 用于重新解释类型,通常用于底层编程,如指针和整数之间的转换,或者不同类型指针之间的转换。它是最不安全的转换。 接下来,我们详细说明每种转换的使用场景和示例,并注意引用格式和数学表达式的LaTeX格式(虽然本问题可能较少涉及数学公式,但如果有表达式则按规则处理)。 注意:在回答中,我们会在适当位置添加引用标记[^1][^2]。</think>### C++ 四种类型转换详解:static_cast、dynamic_cast、const_cast、reinterpret_cast C++ 的四种类型转换运算符提供了更安全、更明确的类型转换方式,替代了 C 语言中简单粗暴的 `(type)value` 强制转换。以下是它们的核心区别和使用场景: | 转换类型 | 主要用途 | 安全性 | 典型场景 | |------------------|--------------------------------------------------------------------------|--------|--------------------------------------------------------------------------| | **static_cast** | 编译时类型转换 | ★★★☆ | 基本类型转换、继承类指针/引用转换 | | **dynamic_cast** | 运行时安全的多态类型转换 | ★★★★☆ | 类继承体系中的向下转型(父类→子类) | | **const_cast** | 添加/移除 `const` 或 `volatile` 限定符 | ★★☆☆ | 与需要修改 `const` 对象的旧代码交互 | | **reinterpret_cast** | 低级的二进制位重新解释 | ☆☆☆☆ | 系统编程、硬件操作、函数指针转换 | --- #### 1. static_cast:编译时类型转换 **使用场景**: - 基本数据类型转换(如 `int`→`double`) - 类继承体系中的向上转型(子类→父类) - 显式类型转换(替代 C 风格强制转换) **示例**: ```cpp double d = 3.14; int i = static_cast<int>(d); // 基本类型转换 $i = \lfloor d \rfloor$ class Base {}; class Derived : public Base {}; Derived* d_ptr = new Derived(); Base* b_ptr = static_cast<Base*>(d_ptr); // 向上转型(安全) ``` **特点**: - 编译时完成,无运行时开销 - 不进行运行时类型检查(向下转型可能不安全) - 不能移除 `const` 限定符 --- #### 2. dynamic_cast:运行时安全的多态转换 **使用场景**: - 类继承体系中的向下转型(父类→子类) - 多态类型的安全转换(需虚函数支持) **示例**: ```cpp class Animal { virtual void move() {} }; // 必须有虚函数 class Dog : public Animal {}; Animal* animal = new Dog(); Dog* dog = dynamic_cast<Dog*>(animal); // 安全向下转型 if (dog) { // 转换成功检查 // 使用 dog 指针 } else { // 处理转换失败 } ``` **特点**: - 运行时类型检查(失败返回 `nullptr` 或抛出异常) - 仅适用于多态类型(类需有虚函数) - 性能开销较高(需 RTTI 支持) --- #### 3. const_cast:常量性修改 **使用场景**: - 临时移除 `const` 限定符 - 与旧式 API 交互(如修改第三方库的 `const` 参数) **示例**: ```cpp void legacyAPI(char* str); // 旧式非 const 接口 const char* msg = "Hello"; legacyAPI(const_cast<char*>(msg)); // 临时移除 const ``` **特点**: - 唯一能操作 `const/volatile` 的转换 - **危险操作**:修改原始 `const` 对象导致未定义行为 - 典型用法:`const T*` → `T*` --- #### 4. reinterpret_cast:底层二进制重新解释 **使用场景**: - 指针与整数间的转换(如地址值操作) - 不相关指针类型间的转换 - 函数指针类型转换 **示例**: ```cpp int* p = new int(65); uintptr_t addr = reinterpret_cast<uintptr_t>(p); // 指针→整数 char* c = reinterpret_cast<char*>(p); // int* → char* std::cout << *c; // 输出 'A'(ASCII 65) ``` **特点**: - 最危险的转换(完全依赖程序员保证正确性) - 常用于系统编程(驱动开发、内存操作) - 可移植性差,应作为最后手段[^1][^2] --- ### 关键对比总结 | 特性 | static_cast | dynamic_cast | const_cast | reinterpret_cast | |---------------------|-------------------|-------------------|-------------------|-------------------| | **转换时机** | 编译时 | 运行时 | 编译时 | 编译时 | | **安全性检查** | 无 | 有 | 无 | 无 | | **多态类要求** | 不需要 | 需要虚函数 | 不需要 | 不需要 | | **常量性修改** | 不可 | 不可 | 可 | 不可 | | **适用场景** | 常规类型转换 | 安全向下转型 | 移除 const | 底层二进制操作 | > **经验法则**: > 1. 优先使用 `static_cast`(常规转换) > 2. 多态类型向下转型用 `dynamic_cast` > 3. 避免 `const_cast` 和 `reinterpret_cast`(除非必要)[^1][^2] --- #### 综合应用示例 ```cpp class Base { virtual void foo() {} }; class Derived : public Base {}; const Derived* cd = new Derived(); // 1. 移除 const(危险!) Derived* d = const_cast<Derived*>(cd); // 2. 安全向下转型 Base* b = d; Derived* dd = dynamic_cast<Derived*>(b); // 3. 指针地址操作 uintptr_t addr = reinterpret_cast<uintptr_t>(dd); ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值