面试cast：reinterpret_cast/const_cast/static_cast/dynamic_cast

目录

1. cast

2. reinterpret_cast 

3. const_cast

3.1 加上const的情况

3.2 去掉const的情况

4. static_cast

4.1 基本类型之间的转换

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;// pxcout << 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中，若继续通过指针使用该对象必然会导致错误，所以这个转换是不安全的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/211578.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【AIGC重塑教育】AI大爆发的时代，未来的年轻人怎样获得机会和竞争力？

【AIGC重塑教育】AI大爆发的时代，未来的年轻人怎样获得机会和竞争力？

目录 AI浪潮来袭 AI与教育 AI的优势 延伸阅读 推荐语 ​作者&#xff1a;刘文勇 来源&#xff1a;IT阅读排行榜 本文摘编自《AIGC重塑教育&#xff1a;AI大模型驱动的教育变革与实践》&#xff0c;机械工业出版社出版 AI浪潮来袭 这次&#xff0c;狼真的来了。 AI正迅猛地…
阅读更多...
NVM管理node版本

NVM管理node版本

使用nvm管理node版本&#xff08;详细教程和报错解决方案&#xff09; 一、下载NVM二、选择NVM安装路径三、然后是选择node的安装位置四、查询版本号五、配置下载镜像六、使用NVM七、报错解决 nvm是一个node版本管理工具&#xff0c;通过它可以安装多种node版本并且可以快速、简…
阅读更多...
烫伤事件屡有发生，觅光推脱责任，称是用户操作失误

烫伤事件屡有发生，觅光推脱责任，称是用户操作失误

提及“双十一”“直播间”等关键词&#xff0c;人们常常将其与“低价”“薅羊毛”等字眼挂钩。而在近日&#xff0c;科技美容品牌AMIRO觅光&#xff08;下称“觅光”&#xff09;却上演了一出“反向薅羊毛”的戏码&#xff0c;因线上线下渠道相差超千元的价格差饱受争议。 自横…
阅读更多...
ubuntu22.04系统下载程序和依赖，并拷贝到指定路径下

ubuntu22.04系统下载程序和依赖，并拷贝到指定路径下

脚本1 apt install aptitude apt-get -d install xxx #xxx是待下载的安装包 mv /var/cache/apt/archives/* /home/tuners/1apt install aptitude apt-get -d install xxx mv /var/cache/apt/archives/*.deb /home/tuners/1 xxx 为程序包名称 /home/tuners/1为保存程序包的…
阅读更多...
camera-caps：Jetson设备上的一种实用的V4L2可视化界面

camera-caps：Jetson设备上的一种实用的V4L2可视化界面

camera-caps&#xff1a;Jetson设备上的一种实用的V4L2可视化界面 github地址是&#xff1a; https://github.com/jetsonhacks/camera-caps 注意&#xff1a;Jetpack5.x需要选择tag 5.x版本
阅读更多...
【LeetCode刷题-回溯】-- 46.全排列

【LeetCode刷题-回溯】-- 46.全排列

46.全排列 方法&#xff1a;回溯法 一种通过探索所有可能的候选解来找出所有的解的算法&#xff0c;如果候选解被确认不是一个解&#xff0c;回溯法会通过在上一步进行一些变化抛弃该解&#xff0c;即回溯并且再次尝试 使用一个标记数组表示已经填过的数 class Solution {pu…
阅读更多...
快速了解敏捷测试！解密敏捷测试的难点！

快速了解敏捷测试！解密敏捷测试的难点！

随着敏捷开发模式的普及&#xff0c;越来越多的测试同仁也开始了敏捷测试。那么究竟什么是敏捷测试&#xff1f;敏捷测试与传统测试的主要区别是什么&#xff1f;敏捷测试的难点又是什么&#xff1f;本文会对这三个问题进行讲解。注意&#xff1a;本文只是讲解敏捷测试概念相关…
阅读更多...
计算方法 期末总结

计算方法 期末总结

思维导图 绪论 算法的性质&#xff1a; 有穷性、确切性、有输入输出、可行性 算法的描述方法&#xff1a; 自然语言、伪代码、流程图、N-S流程图 算法设计思想&#xff1a; 化大为小的缩减技术&#xff1a;二分法化难为易的校正技术&#xff1a;开方法化粗为精的松弛技术&a…
阅读更多...
首批！创邻科技入选《图数据库金融应用场景优秀案例》

首批！创邻科技入选《图数据库金融应用场景优秀案例》

11月11日&#xff0c;“全球金融科技中心网络年会”在第三届全球金融科技大会暨第五届成方金融科技论坛上成功在京举办。会上&#xff0c;北京前沿金融监管科技研究院发布了基于国际标准组织——国际关联数据基准委员会&#xff08;LDBC&#xff09;的《图数据库金融应用场景优…
阅读更多...
【Python入门篇】——Python中循环语句（for循环的基础语法）

【Python入门篇】——Python中循环语句（for循环的基础语法）

作者简介&#xff1a; 辭七七&#xff0c;目前大一&#xff0c;正在学习C/C&#xff0c;Java&#xff0c;Python等 作者主页&#xff1a; 七七的个人主页 文章收录专栏&#xff1a; Python入门&#xff0c;本专栏主要内容为Python的基础语法&#xff0c;Python中的选择循环语句…
阅读更多...
如何解决tinder注册失败的问题？

如何解决tinder注册失败的问题？

tinder创立在2012年&#xff0c;是一款海外热门的交友软件。2020年&#xff0c;Tinder拥有620万用户和7500万月活跃用户。截至2021年&#xff0c;Tinder在全球范围内的匹配记录超过650亿。已成为全球最受欢迎的约会软件之一。 目前tinder暂时未对中国大陆开发使用&#xff0c;…
阅读更多...
机器学习之危险品车辆目标检测

机器学习之危险品车辆目标检测

危险品的运输涉及从离开仓库到由车辆运输到目的地的风险。监控事故、车辆运动动态以及车辆通过特定区域的频率对于监督车辆运输危险品的过程至关重要。 在线工具推荐&#xff1a; 三维数字孪生场景工具 - GLTF/GLB在线编辑器 - Three.js AI自动纹理化开发 - YOLO 虚幻合成数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023