C++面向对象（OOP）编程-四种类型转换

本文主要介绍C/C++的四中强制类型转换，包括static_cast、const_cast、dynamic_cast、reinterpret_cast。
?

目录

1 C/C++类型转换

2 四种强制类型转换

2.1?static_cast

2.2?reinterpret_cast

2.3 const_cast

2.4?dynamic_cast

3 RTTI

4 面试题

5 智能指针的四种强制转换

---

1 C/C++类型转换

? ? ? ? C语言中类型的转换发生在不同类型之间的赋值，可以是隐式类型转换，也可以是显式类型转换。隐式类型转换发生在类型相近的情况下，类型不相近会发生编译错误。

? ? ? ? C++强制类型转化，引入了四种操作符：static_cast 、const_cast、reinterpret_cast、dynamic_cast。

? ? ? ? 隐式类型转换可能会出现问题，比如会发生精度的丢失。显示类型转换将所有的情况混合到一起也不够清晰。

? ? ? ? 于是C++就引入了四种比较清晰的强制类型转换：

? ? ? ? 以下是四种强制转换类型的对比：

关键字	说明
static_cast	用于良性转换，一般不会导致意外发生，风险很低。
const_cast	用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast	高度危险的转换，这种转换仅仅是对二进制位的重新解释，但是可以实现最灵活的 C++ 类型转换。
dynamic_cast	用于类型安全的向下转型。或者向上转。

2 四种强制类型转换

2.1?static_cast

????????static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关的类型进行转换。

? ? ? ? char 类型字符可以转换为int 类型，但是char [] 和string 不可以转换为int类型。

一个简单的例子;

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{

    { // static_cast

        double a1 = 34.8;

        int a2 = 10;

        char a3[] = "Hubery";

        char *a4 = "Tom";

        cout << "a2 转换前: " << a2 << endl;
        cout << "a4 转换前: " << a4 << endl;

        a2 = static_cast<int>(a1);
        // a2 = static_cast<int>(a3); 错误
        a4 = static_cast<char *>(a3);

        cout << "a2 转换后: " << a2 << endl;
        cout << "a4 转换后: " << a4 << endl;

    }

    return 0;
}

? ? ? ? 运行结果;

2.2?reinterpret_cast

????????reinterpret_cast用于任意类型的转换，即reinterpret_cast运算符允许将任意指针转换到其他指针类型，也允许做任意整数类型和任意指针类型之间的转换。转换时，执行的是逐个比特复制的操作。reinterpret中文意为“重新解释; 重新诠释;”。

????????reinterpret_cast使用注意事项：

????????从本质上说所有这些转换都是不安全的，依赖于实现的，或两者都是， reinterpret也不例外（存在安全性）。这种安全性只能由程序员自己来保证。

一个例子：

{ // reinterpret_cast
        __LOG__("reinterpret_cast");

        int num = 0x00636261;//用16进制表示32位int，0x61是字符'a'的ASCII码
        int * pnum = #
        char * pstr = reinterpret_cast<char *>(pnum);
        cout<<"pnum指针的值: "<<pnum<<endl;
        cout<<"pstr指针的值: "<<static_cast<void *>(pstr)<<endl;//直接输出pstr会输出其指向的字符串，这里的类型转换是为了保证输出pstr的值
        cout<<"pnum指向的内容: "<<hex<<*pnum<<endl;
        cout<<"pstr指向的内容: " << pstr<<endl;

        char c = 'a';
        
        int c1 = static_cast<int>(c);
        
        cout << hex << c1 << endl;

        uint8_t d = 97;

        char c2 = static_cast<char>(d);
        cout << c2 << endl;
    }

? ? ? ? 运行结果：

2.3 const_cast

????????const_cast最常用的用途就是删除变量的const属性，方便赋值。

一个例子：

{
        // static_cast
        __LOG__("static_cast");
        const int a = 3;
        int* pa = const_cast<int*>(&a);
        (*pa)++;
        cout << a << endl;   //3
        cout << (*pa) << endl;  //4

    }

? ? ? ? 运行结果：

? ? ? ? 分析结果:

????????代码中const_cast 取消了 &a 的const属性，因而我们可以通过pa指针修改a的值。

打印出的a的值与pa指向的值不一样是编译器优化的结果，因为编译器认为const修饰的a不会被修改，所以直接将a存储到了寄存器里面，当需要读取a时直接就从寄存器里读取了，而我们修改的是内存中a的值，通过指针读取的是内存里的a。

解决上面的问题需要用到volatile关键字，它能帮助我们保持内存的可见性，不让编译器进行这种优化。

? ? ? ? 如下：

{
        // static_cast
        __LOG__("static_cast");
        volatile const int a = 3;
        int* pa = const_cast<int*>(&a);
        *pa = *pa+1;
        cout << a << endl;   //3
        cout << (*pa) << endl;  //4


    }

? ? ? ? 运行结果：

2.4?dynamic_cast

????????dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换):

????????向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则，即我们常说的切割/切片)

????????向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

????????注意点：

????????1. dynamic_cast只能用于父类含有虚函数的类，因为运行类型检查时需要运行时的类型信息，而这个信息是存储在虚函数表中的，所以父类需要含有虚函数。

父类没有虚函数会直接报错。

????????2 dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

????????如果父类指针指向的是父类对象，进行向下转型时会直接返回空指针

????????如果父类指针指向的是子类对象，就转换成功。

一个例子：

#include <iostream>
#include <string>
#include "common.h"
#include <stdint.h>

using namespace std;

class A
{
    private:
        int msg_;
    public:
        virtual void print()
        {
            cout << " 这是一个父类 " << endl;
        }
};

class B : public A
{
    public:
        virtual void print()
        {
            cout << " 这是一个子类 " << endl;
        }
};

int main(int argc, char *argv[])
{

    {
        __LOG__("dynamic_cast");
        A a;
        B b;
        A* pa = &a;    //父类指针指向父类对象
        A* pb = &b;    //父类指针指向子类对象
        B* pA = dynamic_cast<B*>(pa);   //转换失败
        B* pB = dynamic_cast<B*>(pb);   //转换成功
        cout << "pA:"<<pA << endl;
        cout << "pB:" << pB << endl;

    }

    return 0;
}

? ? ? ? 运行结果：

3 RTTI

? ? ? ? 指的是运行时类型识别。

?C++通过以下方式来支持RTTI：

1. typeid运算符?： 在运行时识别出一个对象的类型。

2. dynamic_cast运算符?： 在运行时识别一个父类的指针（或者引用）指向的是父类对象还是子类对象。返回值为0说明父类指针指向的是父类对象，反之指向的是子类对象。

3. decltype?： 在运行时推演出一个表达式或者函数返回值的类型。

4 面试题

请说出C++中的强制类型转换以及它们的应用场景。

????????static_cast: 用于相似类型的转换。

????????reinterpret_cast: 可以用于不同类型的转换。

????????const_cast: 删除变量的const属性，方便赋值。

????????dynamic_cast: 用于安全的实现向下转型，安全的将父类的指针（或引用）转换成子类的指针（或引用）。

5 智能指针的四种强制转换

????????static_pointer_cast、reinterpret_pointer_cast、const_pointer_cast、dynamic_pointer_cast四种，这四种针对的是智能指针的转换。使用的性质与上述提到的基本的类型转换类似。仅仅只是限制是智能指针。