浅谈static_cast、dynamic_cast、const_cast、reinterpret_cast用法

已于 2022-07-21 17:36:34 修改
阅读量1.5k 收藏 39
点赞数 4
分类专栏： C/C++ 文章标签： c++
于 2022-07-21 17:24:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43712770/article/details/125893843
版权

C++中的类型转换分两种：隐式类型转换和显式类型转换。

隐式转换，是标准的转换，很多时候是默认情况下由编译器进行转换；

显式转换，在C++中有四个类型的转换符：static_cast、dynamic_cast、const_cast、reinterpret_cast。

1. static_cast用法

      转换格式：

  1. 将expression转换为type_id类型，主要用于非多态类型之间的转换；
  2. static_cast转换，不能转换掉expression的const、volatile、和_unaligned属性

static_cast<type_id>(expression)

  • 场景1，用于类层次结构中，基类和子类之间的指针或引用的转换

        【1】上行转换，子类指针或引用转父类，这种转换是安全的。

         多态类型之间转换：使用static_cast和使用dynamic_cast效果一样；

         非多态类型之间转换：只能使用static_cast，使用dynamic_cast会编译报错；

//先定义一个父类A，和子类B
class A
{
public:
	virtual void Func() { cout << "A::Func()" << endl; }
};

class B : public A
{
public:
	void Func() override { cout << "B::Func()" << endl; }
};

int main()
{
    A* pa = new B;
    A* a = static_cast<B*>(pb);//ok，转换是安全的

    B* pb = new B;
    A* a = static_cast<B*>(pb);//ok，转换是安全的
    return 0;
}

        【2】下行转换，父类指针或引用转子类，这种转换是不安全的

int main()
{
    //B* pb = new A;    //error，编译报错，无法从A*转换为B*
    A* pa = new A;
    B* b = static_cast<B*>(pa); //ok，编译无误，b != nullptr，这是不安全的，没有做类型检查
    return 0;
}
  • 场景2，用于基本数据类型之间的转换，如把int转成char，把int转换成enum等等，这种转换是不安全的

        char转int，是安全的

int iVar1 = 10;
char cVar1 = 'a';
iVar1 = static_cast<int>(cVar1);
cout << iVar1 << endl;

        int转char，是不安全的，由ASSIC表得出，只有int[32,126]区间，转换才是安全的

int iVar2 = 10;
char cVar2 = 'a';
cVar2 = static_cast<char>(iVar2);
cout << cVar2 << endl;
  •  场景3，把void指针转换成目标类型，这种转换是及其不安全的，编译报错
int a = 10;
void* pa = &a;

int b = static_cast<int>(pa);
cout << b << endl;

float c = static_cast<float>(pa);
cout << c << endl;

  •  另外，static_cast转换，不能转换掉expression的const、volatile、和_unaligned属性
const int iVar = 110;
int* pVar1 = static_cast<int*>(&iVar);//编译报错
const int* pVar2 = static_cast<const int*>(&iVar);//编译无误，通过

2. dynamic_cast用法

        转换格式：

  1. 将expression转换为type-id类型，type-id必须是类的指针或引用或void*;
  2. 如果type-id是指针类型，那么expression也必须是一个指针；
  3. 如果type-id是引用类型，那么expression也必须是一个引用；
  4. dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换；其中进行上行转换时，dynamic_cast和static_cast的效果一样；进行下行转换时，dynamic_cast具有类型检查功能，比static_cast更安全；
  5. 在多态类型之间转换主要使用dynamic_cast，因为类型提供了运行时信息。

dynamic_cast<type_id>(expression)

  • 场景1，用于类层次结构中，基类和子类之间的指针或引用的转换

        【1】上行转换（单继承），子类指针或引用转父类，这种转换是安全的。

         多态类型之间转换：使用static_cast和使用dynamic_cast效果一样；

         非多态类型之间转换：只能使用static_cast，使用dynamic_cast会编译报错；

class A
{
public:
	virtual void Func(){cout << "A::Func()" << endl;}
};

class B: public A
{
public:
	virtual void Func() override{cout << "B::Func()" << endl;}
};

int main()
{
    B* pb = new B;
    A* a1 = dynamic_cast<A*>(pb); //OK
    a1->Func();

    A* pa = new B;
    A* a2 = dynamic_cast<A*>(pa); //OK
    a2->Func();
    return 0;
}

        如果Func为virtual，输出结果：        

        如果Func为非virtual，输出结果：    

       【2】上行转换（多重继承），子类指针或引用转父类，这种转换是安全的 

class A
{
public:
	virtual void Func(){}
};

class B: public A
{
public:
	virtual void Func() override{}
};

class C : public B
{
public:
	virtual void Func() override{}
};

int main()
{
    C* c = new C;
    B* b = dynamic_cast<B*>(c); //OK
    A* a = dynamic_cast<A*>(c); //OK
}
  • 场景2，将类转换为void*，A类和B类中必须包含虚函数。

        原因，类中存在虚函数，说明有想让基类指针或引用指向派生类对象的情况，此时转换才有意义；由于运行时类型检查需要运行时类型信息（该运行信息存储在类的虚函数表中），所以只有定义了虚函数的类才有虚函数表。

class A
{
public:
	virtual void Func() {} //注意关键字virtual
	// ......
};
class B : public A
{
public:
	virtual void Func() {} //注意关键字virtual
	// ......
};
int main()
{
	A *pA = new A;
	B *pB = new B;
	void *pV = dynamic_cast<void *>(pA); // pV points to an object of A
	pV = dynamic_cast<void *>(pB); // pV points to an object of B

	system("pause");
	return 0;
}

          去掉virtual关键字，会编译报错 

  • 场景3，如果expression类型是type-id的基类，使用dynamic_cast进行转换时，在运行时会检查expression是否真正的指向一个type-id类型的对象。如果是，则能进行正确的转换，得到真正的值；否则返回NULL；如果是引用，则在运行时就会抛出异常。

        【1】下行转换（单继承），父类指针或引用转子类，会做类型安全检查，这种转换是安全的

class A
{
public:
	virtual void Func(){cout << "A::Func()" << endl;}
};

class B: public A
{
public:
	virtual void Func() override{cout << "B::Func()" << endl;}
};

int main()
{
    //B* pb = new A;             //error，编译报错，无法从父类A*转换为子类B* 
   
    /*
    * 由父类A*转换子类B*，使用dynamic_cast能做到安全检查，转换失败会返回null;
    * 使用static_cast不安全
    */
    A* pa1 = new B;
    B* b1 = dynamic_cast<B*>(pa1); //ok，编译无误，b != nullptr
    if (nullptr != b1) 
    {
        b1->Func();
    }

    A* pa2 = new A;
    B* b2 = dynamic_cast<B*>(pa2); //ok，编译无误，b = nullptr
    if (nullptr != b2) 
    {
        b2->Func();
    }
    return 0;
}

        【2】 对于一些复杂继承关系，使用dynamic_cast进行转换是存在一些陷阱的

        如下做法存在陷阱，

class A
{
	virtual void Func() = 0;
};
class B : public A
{
	void Func() { cout << "B::Func()" << endl; }
};
class C : public A
{
	void Func() { cout << "C::Func()" << endl; };
};
class D : public B, public C
{
	void Func() { cout << "D::Func()" << endl; }
};
int main()
{
	D *pD = new D;

    /*
    * B和C都继承了A，并且都实现了虚函数Func，导致在进行转换时，无法进行抉择应该向哪个A进行转换
    */
	A *pA = dynamic_cast<A *>(pD); // pA = NULL
	//pA->Func();

	system("pause");
	return 0;
}

         正确的做法是，像多重继承关系这种情况，需要把子类逐步转换到父类

int main()
{
    D *pD = new D;
    B *pB = dynamic_cast<B *>(pD);
    A *pA = dynamic_cast<A *>(pB);
    return 0;
}

3. const_cast用法

       转换格式：const_cast用来将类型的const、volatile和_unaligned属性移除。

  1. 常量指针被转换为非常量指针，并且仍然指向原来的对象；
  2. 常量引用被转换为非常量引用，并且仍然引用原来的对象；
  3. 不能直接对非指针和非引用的变量使用const_cast操作符去直接移除它的const、volatile和__unaligned属性。

const_cast <type-id> (expression)

  • 场景1，常量指针转非常量指针
class A
{
public:
	A() :m_iA(10) {}
	int m_iA;
};
int main()
{
	//常量指针转非常量指针
	const A *pA = new A;
	//pA->m_iA = 100;			//error，pA常量指针，指向的内容不能修改
	cout << pA->m_iA << endl;

	A *pB = const_cast<A*>(pA);	//去const属性
	pB->m_iA = 100;				//通过指针，修改值

	//指针pA和pB指向同一个对象
	cout << pA->m_iA << endl;
	cout << pB->m_iA << endl;

    return 0;
}
  • 场景2，指针常量转非指针常量
class A
{
public:
	A() :m_iA(10) {}
	int m_iA;
};

int main()
{
	//常量指针转非常量指针
	A * const pA1 = new A;
	pA1->m_iA = 100;			    //ok，pA是指针常量，指向的内容可以修改
	cout << pA1->m_iA << endl;

	A *pA2 = new A;
	//pA1 = pA2;					//error，pA是指针常量，指向的地址不能修改

	A *pB = const_cast<A*>(pA1);	//去const属性
	pB = pA2;						//通过指针，修改值
	pB->m_iA = 111;

	//指针pA和pB指向同一个对象
	cout << pA1->m_iA << endl;
	cout << pA2->m_iA << endl;
	cout << pB->m_iA << endl;

    return 0;
}
  • 场景3，常量引用转非常量引用
int main()
{
    const int &num = 10;
	//num = 100;			//error，不能给常量赋值
	int &num2 = const_cast<int&>(num);
	num2 = 100;
    return 0;
}
  •  场景4，不能给非常量指针和引用使用const_cast
int main()
{
	const int num1 = 10;
	//int num2 = const_cast<int>(num1);   //error，编译报错，无法从“const int”转换为“int”	
    return 0;
}

4. reinterpret_cast用法

        转换格式：

reinterpret_cast <type-id> (expression)

        reinterpret_cast后的尖括号中的type-id类型必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。 

小胖七少爷
关注
  • 4
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++类型转换运算符dynamic_cast、static_cast 和 reinterpret_cast
啊渊的专栏
04-19 739
和。这些转换运算符可以用来在不同的上下文中进行类型转换，但它们的行为和使用场景是不同的。
C++ 强制类型转换：static_cast、dynamic_cast、const_cast 和 reinterpret_cast
Dong_HFUT的博客
06-18 7509
C++ 强制类型转换：static_cast、dynamic_cast、const_cast 和 reinterpret_cast
类型转换 static_cast、reinterpret_cast等
最新发布
weixin_39126199的博客
06-27 360
1、强制类型转换能抑制编译器报错2、reinterpret_cast危险，使用const_cast意味的设计缺陷3、一般static_cast和reinterpret_cast很好取代C语言类型转换。
C++ 中static_cast、dynamic_cast、const_cast和reinterpret_cast总结
我的博客
07-19 839
C++中的类型转换分为两种： 隐式类型转换； 显式类型转换。 而对于隐式变换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。 在标准C++中有四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将对它们一一的进行总结。 1. static_cast static_cast的转换格式：static_ca
数据类型转换操作符：const_cast、static_cast、dynamic_cast以及reinterpret_cast
Wangguang_的博客
09-20 887
文章目录数据类型转换const_cast的用法使用const_cast需要注意的问题：static_constdynamic_castreinterpret_cast 数据类型转换 在c++编程中,我们经常需要使用到类型转换,但可能不熟悉c++内置的四种类型转换操作符 它们分别是:const_cast、static_cast、dynamic_cast以及reinterpret_cast，它们的语法形式是统一的，type_cast_operator(expression) const_cast主要用于解除
const_cast,dynamic_cast,reinterpret_cast,static_cast四种转换的区别
热门推荐
bajianxiaofendui的博客
02-02 1万+
const_cast,dynamic_cast,reinterpret_cast,static_cast四种转换的区别一，const_cast一，dynamic_cast一，reinterpret_cast一，static_cast C++是一种强类型语言，对类型的检查非常严格，我们可以使用C语言中的（NewType）Expression来对某个变量或者表达式返回值进行强转，也可以使用C++中提供...
掌握C++类型转换：static_cast、const_cast、dynamic_cast 和 reinterpret_cast
Lion_Long的博客
04-20 5154
静态类型转换静态类型转换是最常用的类型转换方式，它可以将一种类型的数据强制转换为另一种类型，但需要注意的是，这种转换可能会损失一些信息，因此在进行此类转换时应当谨慎。int a = 10;动态类型转换动态类型转换主要用于多态类型之间的转换，它可以将基类指针或引用转换为派生类指针或引用。如果进行非法的类型转换，动态类型转换会返回一个空指针。重新解释类型转换。
static_cast、dynamic_cast、const_cast和reinterpret_cast
Vvlowkey的专栏
10-12 322
声明 本文转自http://www.jellythink.com/archives/205 仅用作学习收藏，原作者如有异议，请联系删除。 前言 这篇文章总结的是C++中的类型转换，这些小的知识点，有的时候，自己不是很注意，但是在实际开发中确实经常使用的。俗话说的好，不懂自己写的代码的程序员，不是好的程序员；如果一个程序员对于自己写的代码都不懂，只是知道一昧的的去使用，终有一
C/C++中的数据类型转换()/static_cast/dynamic_cast/const_cast/reinterpret_cast
AlbertS Home of Technology
07-12 1万+
C/C++属于静态语言，也就是在编译时变量的数据类型即可确定的强类型语言。当不同的数据类型在一起运算或者相互赋值的时候，就需要进行数据类型转换。不同数据类型占用的内存空间不同，而各种数据类型的转换时有规则的，一种通用的规则就是“小转大”自动进行，“大转小”需要强制执行。这里的“大”和“小”指的是数据范围...
c++ 数据类型转换： static_cast、dynamic_cast、reinterpret_cast和const_cast
YBAdiam的博客
12-19 385
【目录】 引言 static_cast 定义 dynamic_cast 定义 举例：下行转换（把基类的指针或引用转换成子类表示） 举例：上行转换（把子类的指针或引用转换成基类表示） 举例: static_cast 用于基本类型之间、基本类型指针和空指针间的转换 reinterpret_cast 定义 举例：reinterpret_cast用法 const_cast 定义 举例：...
C++之友元类
小胖七少爷的博客
08-31 2930
一个类 A 可以将另一个类 B 声明为自己的友元，类 B 的所有成员函数就都可以访问类 A 对象的私有成员。在类定义中声明友元类的写法如下： friend class 类名; 友元类B类的所有成员函数，都能访问A类对象的私有成员； 类 A 将类 B 声明为友元类，则类 B 最好从逻辑上和类 A 有比较接近的关系。例如上面的例子，CDriver 代表司机，CCar 代表车，司机拥有车，所以 CDriver 类和 CCar 类从逻辑上来讲关系比较密切，把 CDriver...
C输入输出格式控制符汇总
小胖七少爷的博客
10-23 2175
printf() 格式控制符汇总 格式控制符 说明 %c 输出一个单一的字符 %hd、%d、%ld 以十进制、有符号的形式输出 short、int、long 类型的整数 %hu、%u、%lu 以十进制、无符号的形式输出 short、int、long 类型的整数 %ho、%o、%lo 以八进制、不带前缀、无符号的形式输出 short、int、long ...
求空间向量夹角
小胖七少爷的博客
08-21 2142
//以下计算需要换算成局部坐标系下 /* 假设球机摄像头坐标为pos1(x1, y1, z1),枪机上拾取的点坐标为pos2(x2, y2, z2); 如果换算成局部坐标系，把球机摄像头作为原点O的话，那么球机摄像头pos1（0,0,0），枪机pos2(x2-x1, y2-y1, z2-z1); 再传入TwoPointsAngle函数中，计算出球机的转向 */ #ifndef _VEC3D #...
函数调用的几种方式:__cdecl、__stdcall、__fastcall、__thiscall、__clrcall、__vectorcall
小胖七少爷的博客
07-31 1724
调用约束，__cdecl/__stdcall/__fastcall
C++ std::function的用法
小胖七少爷的博客
10-13 1303
类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。std::function对象是对C++中现有的可调用实体的一种类型安全的包裹（我们知道像函数指针这类可调用实体，是类型不安全的）。 通常std::function是一个函数对象类，它包装其它任意的函数对象，被包装的函数对象具有类型为T1, …,TN的N个...
unary_function和binary_function详解
小胖七少爷的博客
07-27 993
unary_function和binary_function
not1|not2和bind1st|bind2nd详解
小胖七少爷的博客
07-28 989
not1、not2、bind1st、bind2nd
GCJ-02和BD-09互转、GCJ-02和WGS-84互转
小胖七少爷的博客
11-01 967
/** * GCJ02 转换为 WGS84 * @param lng * @param lat * @returns {*[]} */ struct Point { double lon; double lat; }; double x_PI = 3.14159265358979324 * 3000.0 / 180.0; double PI = 3.1415926535897932384626; double a = 6378245.0; double ee = 0.006693421622965.
C++类型转换详解：static_cast, const_cast, dynamic_cast, reinterpret_cast
本教程主要涵盖四种类型的类型转换：`static_cast`, `const_cast`, `dynamic_cast` 和 `reinterpret_cast`，以及`explicit`关键字的使用。" C++中的类型转换分为显式和隐式两种。显式类型转换，如C风格的类型转换，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小胖七少爷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值