面试cast：reinterpret_cast/const_cast/static_cast/dynamic_cast

诸葛剑问

已于 2023-11-23 21:02:12 修改

阅读量511

点赞数 2

文章标签：算法面试 c++ linux

于 2023-11-23 20:59:50 首次发布

本文链接：https://blog.csdn.net/weixin_41654661/article/details/134585052

版权

4.2 void指针转换为任意基本类型的指针

4.3 子类和父类之间的转换

5. dynamic_cast

5.1 RTTI(Run-time Type Identification)

1. cast

英 /kɑːst/ 美 /kæst/

v. 铸造;投（钓线）;投票;投射(光、影子等);扔;使人怀疑;向…投以(视线、笑容等);分配角色;（蛇）蜕（皮）;造谣中伤;踢落;把某人描写成

n. 铸件;铸模;特性;模子;铸造品;(一出戏剧或一部电影的)全体演员

在C++程序里是一种转型机制，跟物理铸造差不多，有一个模子（如int），然后根据这个模子生成一个铸件。

double a = 1.1;
char* b = reinterpret_cast<char*>(&a);
// char*就是一个新的模具，double指针是原料，通过铸造case变成一个新的铸件b

2. reinterpret_cast

reinterpret

英 /ˌriːɪnˈtɜːprət/，美 /ˌriːɪnˈtɜːrprət/

vt. 重新解释;重新诠释

reinterpret_cast是四种强制转换中功能最为强大的（最暴力，最底层，最不安全），跟它的英文释义一样重新诠释。它的本质是编译器的指令。

它的作用：它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。或者不同类型的指针的相互替换

代码示例：

#include <iostream>
int main()
{
    double a = 1.1;
    char* b = reinterpret_cast<char*>(&a);
    double* c = reinterpret_cast<double*>(b);
    printf("a:%lf, %p\n", a, &a);
    printf("b:%c, %p\n", *b, b);
    printf("c:%lf, %p\n", *c, c);
}

输出：

我尝试打断点进入reinterpret_cast内部，发现并不行（它的本质是编译器的指令）。

通过中间的 char*来转double*，但是没有出现精度问题。事实上reinterpret_cast只是在编译器进行的予以转化（并未拷贝，只是重新诠释），只要是个地址就可以转（二进制拷贝）。

3. const_cast

有两个功能，去掉const和加上const。

3.1 加上const的情况

#include <iostream>
int main()
{
    int* a = new int(1);
    const int* b = const_cast<const int*>(a);
    *a = 2;
    //*b=2;，常量不能修改
    printf("0x%p,%d\n", a,*a);
    printf("0x%p,%d\n", b,*b);
    return 0;
}

输出：

发现值是一样的，但是地址也是一样，说白了加const就是加了一个修饰和限定。

3.2 去掉const的情况

#include <iostream>
class A
{
public:
    int num;
    A(int val = 100) :num(val) {}
    ~A() {}
};
int main()
{
    //1.const 修饰指针对象,指向原对象
    const A* pa1 = new A(200);
    A* cast_pa1 = const_cast<A*>(pa1);
    printf("1.const 修饰指针指向对象,指向原对象\n");
    printf("%p\n", pa1);
    printf("%p\n", cast_pa1);

    //2.const 修饰指向指针对象的值,指向原对象
    A* const pa2 = new A(200);
    A* cast_pa2 = const_cast<A*>(pa2);
    printf("2.const 修饰指向对象的值,指向原对象\n");
    printf("%p\n", pa2);
    printf("%p\n", cast_pa2);

    //3.const 同时修饰指针对象和指针对象的值,指向原对象
    const A* const pa3 = new A(200);
    A* cast_pa3_1 = const_cast<A*>(pa3);
    const A* cast_pa3_2 = const_cast<A*>(pa3);
    A* const cast_pa3_3 = const_cast<A*>(pa3);
    printf("3.const 同时修饰指针对象和指针对象的值,指向原对象\n");
    printf("%p\n", pa3);
    printf("%p\n", cast_pa3_1);
    printf("%p\n", cast_pa3_2);
    printf("%p\n", cast_pa3_3);

    //4.const 修饰普通对象，并且赋值给一般对象,不指向原对象
    const A pa4;
    A cast_pa4 = const_cast<A&>(pa4);
    printf("4.const 修饰普通对象，并且赋值给一般对象\n");
    printf("%p\n", &pa4);
    printf("%p\n", &cast_pa4);

    //5.const 修饰普通对象，并且赋值给引用对象,指向原对象
    const A pa5;
    A& cast_pa5 = const_cast<A&>(pa5);
    printf("5.const 修饰普通对象，并且赋值给引用对象\n");
    printf("%p\n", &pa5);
    printf("%p\n", &cast_pa5);

    // 6. const 修饰对象，对象指针去 const 属性后赋给指针,指向原对象
    const A pa6;
    A* cast_pa6 = const_cast<A*>(&pa6);
    printf("6. const 修饰对象，对象指针去 const 属性后赋给指针\n");
    printf("%p\n", &pa6);
    printf("%p\n", cast_pa6);

    //7.const修饰局部变量，不指向原对象
    const int pa7 = 1;
    int  cast_pa7_1 = const_cast<int&>(pa7);
    int& cast_pa7_2 = const_cast<int&>(pa7);
    int* cast_pa7_3 = const_cast<int*>(&pa7);

    printf("6. const 修饰对象，对象指针去 const 属性后赋给指针\n");
    printf("地址,  pa7:%p\n", &pa7);
    printf("cast_pa7_1:%p\n", &cast_pa7_1);
    printf("cast_pa7_2:%p\n", &cast_pa7_2);
    printf("cast_pa7_3:%p\n", cast_pa7_3);
    cast_pa7_1 = 10;
    printf("pa7:%d,未修改\n", pa7);
    printf("cast_pa7_1:%d\n", cast_pa7_1);
    cast_pa7_2 = 100;
    printf("pa7:%d,未修改\n", pa7);
    printf("cast_pa7_1:%d\n", cast_pa7_1);
    printf("cast_pa7_2:%d\n", cast_pa7_2);
    *cast_pa7_3 = 1000;
    printf("pa7:%d,未修改\n", pa7);
    printf("cast_pa7_1:%d\n", cast_pa7_1);
    printf("cast_pa7_2:%d\n", cast_pa7_2);
    printf("cast_pa7_3:%d\n", *cast_pa7_3);
    return 0;
}

输出

1.const 修饰指针指向对象,指向原对象
016E7820
016E7820
2.const 修饰指向对象的值,指向原对象
016E77C0
016E77C0
3.const 同时修饰指针对象和指针对象的值,指向原对象
016E7850
016E7850
016E7850
016E7850
4.const 修饰普通对象，并且赋值给一般对象
012FFD24
012FFD18
5.const 修饰普通对象，并且赋值给引用对象
012FFD0C
012FFD0C
6. const 修饰对象，对象指针去 const 属性后赋给指针
012FFCF4
012FFCF4
6. const 修饰对象，对象指针去 const 属性后赋给指针
地址,  pa7:012FFCDC
cast_pa7_1:012FFCD0
cast_pa7_2:012FFCDC
cast_pa7_3:012FFCDC
pa7:1,未修改
cast_pa7_1:10
pa7:1,未修改
cast_pa7_1:10
cast_pa7_2:100
pa7:1,未修改
cast_pa7_1:10
cast_pa7_2:1000
cast_pa7_3:1000

分析：

指针之间的转换无论怎样还是原地址

去掉一般对象的const，如果赋值给一般对象则是新对象（A cast_pa4 = const_cast<A &>(pa4);）

去掉内置类型（如int）变量的const，如果赋值给一般对象则是新对象，否则全是原来对象地址（虽然地址是一样的，但是值是不一样的）疑惑中。。。。。。

4. static_cast

三个作用：

1.基本类型之间的转换

2.void指针转换为任意基本类型的指针，基本类型指针之间无法使用

3.用于有继承关系的子类与父类之间的指针或引用的转换

4.1 基本类型之间的转换

#include <iostream>
int main()
{
    double i = 1.1;
    int a = static_cast<int>(i);
    double b = static_cast<double>(a);
    int c = static_cast<int>(b);
    printf("i:%lf, %p\n", i, &i);
    printf("a:%d, %p\n", a, &a);
    printf("b:%lf,%p\n", b, &b);
    printf("c:%d, %p\n", c, &c);
}

输出

可以进行基本类型的转化，但是会损失精度类似与C语言的强制转化。转换过程实际上是有内存拷贝的，每次地址都不一样。跟reinterpret_cast不太一样reinterpret_cast是底层二进制的强制拷贝和语义转换不会损失精度。

注：reinterpret_cast不能进行基本类型之间的转换，只能做指针转换。

4.2 void指针转换为任意基本类型的指针

#include <iostream>
int main()
{
    double a = 1.1;
    void* b = static_cast<void*>(&a);
    double* c = static_cast<double*>(b);
    //int* d = static_cast<int*>(c); // 类型转换无效（基本类型指针之间无法使用）
    printf("a:%lf, %p\n", a, &a);
    printf("b:%p\n", b);
    printf("c:%lf, %p\n", *c, c);
}

这里是void指针和其他类型的指针进行的转化，结果是指向的是原地址，跟reinterpret_cast是一样的结果。说白了static_cast就是能做铁水变铁器和铁器变铁水，但是不能直接把铁镰刀变铁锄头。reinterpret_cast就是可以指鹿为马，能直接把铁镰刀变铁锄头，但是变成的铁锄头能不能刨地就不知道了。这里需要区分普通类型之间的转换和普通类型指针之间的转换（普通类型的转换不是）。

//int* d = static_cast<int*>(c); // 类型转换无效（基本类型指针之间无法使用）

4.3 子类和父类之间的转换

#include <iostream>
using namespace std;
class A
{
    public:
    A(){};
    void foo()
    {
        cout<<"A!"<<endl;
    }
};
class B:public A
{
    public:
    B(){} ;
    void foo()
    {
        cout<<"B!"<<endl;
    }
};
int main()
{
    A *a = new A();
    B * b = static_cast<B *>(a);
    b->foo();
    return 0;
}

输出：

这是向下转型，是不安全的，但是为什么没有报错呢，因为B中还没有B特有的（B的成员变量），A和B两者在内存中的结构是一致的。

举个不一致的例子：


#include <iostream>
using namespace std;
class A
{
    public:
    A(){}
    void foo()
    {
        cout<<"A!"<<endl;
    }
};
class B:public A
{
    char b='c';
    public:
    B(){}
    void foo()
    {
        cout<<b<<endl;
    }
};
int main()
{
    A* a = new A();
    a->foo();
    B* b = static_cast<B*>(a);
    b->foo();
    B* pb = new B();
    pb->foo();
    return 0;
}

输出

分析：这里就发生了错误了，B中特有的成员变量没有初始化（使用了不安全的向下转型）

5. dynamic_cast

dynamic_cast用于类继承层次间的指针或引用转换(主要用于向下的安全转换)

dynamic_cast向下转型的安全性主要体现在RTTI

5.1 RTTI(Run-time Type Identification)

运行时类型识别。程序能够使用基类的指针或引用来检查着这些指针或引用所指的对象的实际派生类型（判断指针原型）

RTTI提供了两个非常有用的操作符：typeid和dynamic_cast。（三个最主要的东西，dynamic_cast,typeid,type_info）

typeid:typeid函数（为type_info类的友元函数，为什么要这样呢？目的是防止创建type_info对象）的主要作用就是让用户知道当前的变量是什么类型的,它可以返回一个type_info的引用，可以获取类的名称和编码typeid重载了type_info中的==和!=可以用于判断两个类型是否相等

1）typeid识别静态类型

当typeid中的操作数是如下情况之一时，typeid运算符指出操作数的静态类型，即编译时的类型。

（1）类型名

（2）一个基本类型的变量

（3）一个具体的对象(非指针对象)

（4）一个指向不含有virtual函数的类对象的指针的解引用

（5）一个指向不含有virtual函数的类对象的引用

静态类型在程序的运行过程中并不会改变，所以并不需要在程序运行时计算类型，在编译时就能根据操作数的静态类型，推导出其类型信息。例如如下的代码片断，typeid中的操作数均为静态类型

#include <iostream>
#include <typeinfo>
using namespace std;
class X {
public:
    X() {   };
    virtual void func() = 0;
};
class XX : public X {
public:
    XX() { };
    void func() { };
};
class Y {
public:
    Y() {  };
    void func() { };
};
int main()
{
    int n = 0;
    XX xx;
    Y y;
    Y* py = &y;
    X* px = &xx;
    // int和XX都是类型名
    cout << typeid(int).name() << endl;
    cout << typeid(XX).name() << endl;
    // n为基本变量
    cout << typeid(n).name() << endl;
    // xx所属的类虽然存在virtual，但是xx为一个具体的对象
    cout << typeid(xx).name() << endl;
    // py为一个指针，属于基本类型
    cout << typeid(py).name() << endl;
    // py指向的Y的对象，但是类Y不存在virtual函数
    cout << typeid(*py).name() << endl;
    // px
    cout << typeid(*px).name() << endl;
    cout << typeid(px).name() << endl;
    return 0;
}

输出：

对于px，px是 class X *，但是*px是class XX。

动态类型转换：

#include <iostream>
#include <typeinfo>
using namespace std;
class X
{
public:
    X() { mX = 101;}
    virtual ~X(){}
private:
    int mX;
};

class XX : public X
{
public:
    XX() :X() { mXX = 1001; }
    virtual ~XX() { }
private:
    int mXX;
};

class YX : public X
{
public:
    YX() { mYX = 1002; }
    virtual ~YX() { }
private:
    int mYX;
};
int main()
{
    X x;
    XX xx;
    YX yx;
    // 子类直接转父类指针，没问题
    X* px = &xx;
    cout << "px:\t" << px << endl;
    XX* pxx = dynamic_cast<XX*>(px); // 转换1，成功
    cout << "pxx:\t" << pxx << endl;
    YX* pyx = dynamic_cast<YX*>(px); // 转换2，失败
    cout << "pyx:\t" << pyx << endl;
    pyx = (YX*)px;                   // 转换3，成功
    cout << "pyx:\t" << pyx << endl;
    pyx = static_cast<YX*>(px);      // 转换4，成功
    cout << "pyx:\t" << pyx << endl;
    return 0;
}

输出：

px是一个基类（X）的指针，但是它指向了派生类XX的一个对象。在转换1中，转换成功，因为px指向的对象确实为XX的对象。在转换2中，转换失败，因为px指向的对象并不是一个YX对象，此时dymanic_cast返回nullptr。转换3为C风格的类型转换而转换4使用的是C++中的静态类型转换，它们均能成功转换，但是这个对象实际上并不是一个YX的对象，所以在转换3和转换4中，若继续通过指针使用该对象必然会导致错误，所以这个转换是不安全的。

诸葛剑问

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面试cast：reinterpret_cast/const_cast/static_cast/dynamic_cast

英 /kɑːst/ 美 /kæst/v.;投（钓线）;投票;投射(光、影子等);扔;使人怀疑;向…投以(视线、笑容等);分配角色;（蛇）蜕（皮）;造谣中伤;踢落;把某人描写成n. 铸件;铸模;特性;模子;铸造品;(一出戏剧或一部电影的)全体演员在C++程序里是一种，跟物理差不多，有一个模子（如int），然后根据这个模子生成一个铸件。
复制链接

扫一扫