【C++ 面试 - 基础题】每日 3 题（十八）

✍个人博客：Pandaconda-CSDN博客

📣专栏地址：http://t.csdnimg.cn/fYaBd

📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

52. C++ 的四种强制转换 reinterpret_cast、const_cast、static_cast、dynamic_cast

reinterpret_cast

reinterpret_cast <type-id> (expression)

type-id 必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以用于类型之间进行强制转换。可以将指针值转换为一个整型数，但不能用于非指针类型的转换。

举个例子：

#include <iostream>
using namespace std;
int main(int argc, char** argv)
{
    int num = 0x00636261;//用16进制表示32位int，0x61是字符'a'的ASCII码
    int * pnum = &num;
    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;
    return 0;
}

在 Ubuntu 14.04 LTS 系统下，采用 g++ 4.8.4 版本编译器编译该源文件并执行，得到的输出结果如下：

第 6 行定义了一个整型变量 num，并初始化为 0x00636261（十六进制表示），然后取 num 的地址用来初始化整型指针变量 pnum。接着到了关键的地方，使用 reinterpret_cast 运算符把 pnum 从int*转变成char*类型并用于初始化 pstr。

将 pnum 和 pstr 两个指针的值输出，对比发现，两个指针的值是完全相同的，这是因为 “reinterpret_cast 运算符并不会改变括号中运算对象的值，而是对该对象从位模式上进行重新解释”。如何理解位模式上的重新解释呢？通过推敲代码 11 行和 12 行的输出内容，就可见一斑。

很显然，按照十六进制输出 pnum 指向的内容，得到 636261；但是输出 pstr 指向的内容，为什么会得到 ”abc” 呢？

在回答这个问题之前，先套用《深度探索 C++ 对象模型》中的一段话，“一个指向字符串的指针是如何地与一个指向整数的指针或一个指向其他自定义类型对象的指针有所不同呢？从内存需求的观点来说，没有什么不同！它们三个都需要足够的内存（并且是相同大小的内存）来放置一个机器地址。指向不同类型之各指针间的差异，既不在其指针表示法不同，也不在其内容（代表一个地址）不同，而是在其所寻址出来的对象类型不同。也就是说，指针类型会教导编译器如何解释某个特定地址中的内存内容及其大小。” 参考这段话和下面的内存示意图，答案已经呼之欲出了。

const_cast

const_cast <type_id> (expression)

该运算符用来修改类型的 const 或 volatile 属性。除了 const 或 volatile 修饰之外， type_id 和 expression 的类型是一样的。用法如下（只能用于指针或者引用）：

常量指针被转化成非常量的指针，并且仍然指向原来的对象。
常量引用被转换成非常量的引用，并且仍然指向原来的对象。
const_cast 一般用于修改底指针。如 const char *p 形式。

static_cast

static_cast <type-id> (expression)

该运算符把 expression 转换为 type-id 类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。
- 进行上行转换（把派生类的指针或引用转换成基类表示）是安全的。
- 进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。
用于基本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum。这种转换的安全性也要开发人员来保证。
把空指针转换成目标类型的空指针。
把任何类型的表达式转换成 void 类型。

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

dynamic_cast

有类型检查，基类向派生类转换比较安全，但是派生类向基类转换则不太安全

dynamic_cast <type-id> (expression)

该运算符把 expression 转换成 type-id 类型的对象。type-id 必须是类的指针、类的引用或者 void*。

如果 type-id 是类指针类型，那么 expression 也必须是一个指针，如果 type-id 是一个引用，那么 expression 也必须是一个引用。

dynamic_cast 运算符可以在执行期决定真正的类型，也就是说 expression 必须是多态类型。如果下行转换是安全的（也就说，如果基类指针或者引用确实指向一个派生类对象）这个运算符会传回适当转型过的指针。如果下行转换不安全，这个运算符会传回空指针（也就是说，基类指针或者引用没有指向一个派生类对象）。

dynamic_cast 主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。

向下类型转换

在类层次间进行上行转换时，dynamic_cast 和 static_cast 的效果是一样的。

在进行下行转换时，dynamic_cast 具有类型检查的功能，比 static_cast 更安全。

举个例子：

#include <bits/stdc++.h>
using namespace std;

class Base
{
public:
        Base() :b(1) {}
        virtual void fun() {};
        int b;
};

class Son : public Base
{
public:
        Son() :d(2) {}
        int d;
};

int main()
{
        int n = 97;

        //reinterpret_cast
        int *p = &n;
        //以下两者效果相同
        char *c = reinterpret_cast<char*> (p); 
        char *c2 =  (char*)(p);
        cout << "reinterpret_cast输出："<< *c2 << endl;
        //const_cast
        const int *p2 = &n;
        int *p3 = const_cast<int*>(p2);
        *p3 = 100;
        cout << "const_cast输出：" << *p3 << endl;
        
        Base* b1 = new Son;
        Base* b2 = new Base;

        //static_cast
        Son* s1 = static_cast<Son*>(b1); //同类型转换
        Son* s2 = static_cast<Son*>(b2); //下行转换，不安全
        cout << "static_cast输出："<< endl;
        cout << s1->d << endl;
        cout << s2->d << endl; //下行转换，原先父对象没有d成员，输出垃圾值

        //dynamic_cast
        Son* s3 = dynamic_cast<Son*>(b1); //同类型转换
        Son* s4 = dynamic_cast<Son*>(b2); //下行转换，安全
        cout << "dynamic_cast输出：" << endl;
        cout << s3->d << endl;
        if(s4 == nullptr)
                cout << "s4指针为nullptr" << endl;
        else
                cout << s4->d << endl;
        
        
        return 0;
}
//输出结果
//reinterpret_cast输出：a
//const_cast输出：100
//static_cast输出：
//2
//-33686019
//dynamic_cast输出：
//2
//s4指针为nullptr

从输出结果可以看出，在进行下行转换时，dynamic_cast 安全的，如果下行转换不安全的话其会返回空指针，这样在进行操作的时候可以预先判断。而使用 static_cast 下行转换存在不安全的情况也可以转换成功，但是直接使用转换后的对象进行操作容易造成错误。

用于多态类型检查

dynamic_cast 底层原理

dynamic_cast 的底层原理依赖于运行时类型信息 (RTTI, Runtime Type lnformation) C++ 编译器在编译时为支持多态的类生成 RTTI，它包含了类的类型信息和类层次结构。我们都知道当使用虚函数时，编译器会为每个类生成一个虚函数表 (vtable) ，并在其中存储指向虚函数的指针。

伴随虚函数表的还有 RTTI (运行时类型信息)，这些辅助的信息可以用来帮助我们运行时识别对象的类型信息。

《深度探索 C++ 对象模型》中有个例子：