C++多重继承下的指针类型转换 图解

最新推荐文章于 2021-01-30 15:36:14 发布
最新推荐文章于 2021-01-30 15:36:14 发布
阅读量1.2k 收藏
点赞数
分类专栏： c++

在C++中，指针的类型转换是经常发生的事情，比如将派生类指针转换为基类指针，将基类指针转换为派生类指针。指针的本质其实就是一个整数，用以记录进程虚拟内存空间中的地址编号，而指针的类型决定了编译器对其指向的内存空间的解释方式。

基于上面的理解，我们似乎可以得出一个结论，C++中对指针进行类型转换，不会改变指针的值，只会改变指针的类型(即改变编译器对该指针指向内存的解释方式)，但是这个结论在C++多重继承下是 不成立的。

看下面一段代码：

Copy to Clipboard Liehuo.Net Codes引用的内容： [www.veryhuo.com]
#include <iostream> 
using namespace std; 

class CBaseA 
{ 
public: 
char m_A[32]; 
}; 

class CBaseB 
{ 
public: 
char m_B[64]; 
}; 

class CDerive : public CBaseA, public CBaseB 
{ 
public: 
char m_D[128]; 
}; 


int main() 
{ 
auto pD = new CDerive; 
auto pA = (CBaseA *)pD; 
auto pB = (CBaseB *)pD; 

cout << pA << '\n' << pB << '\n' << pD << endl; 
cout << (pD == pB) << endl; 
}

这段代码的输出是：

0x9f1080
0x9f10a0
0x9f1080
1

可以看出，指向同一个堆上new出来的内存指针，在经过类型转换之后，其值会发生改变。究其原因，要从C++中多重继承的内存布局说起。

new CDerive;执行之后，生成的内存布局如下：


 

同时我们注意到，pB与pD的指针差值正好是CBaseA占用的内存大小32字节，而pA与pD都指向了同一段地址。这是因为，将一个派生类的指针转换成某一个基类指针，编译器会将指针的值偏移到该基类在对象内存中的起始位置。

可是为什么C++要这样设计呢？

试想，沿用上面的场景，如果pB和pA都指向对象的首地址，那么使用pB指针来定位CBaseB的成员变量m_B时，编译器应该将pB指针偏移32个字节，从而跳过CBaseA的内存部分。而pB指针如果是这样产生的auto pB = new CBaseB；，那么使用pB指针来定位CBaseB的成员变量m_B时，偏移量应该为0。

关键在于对于一个指针而言，编译器不关心也无法知道该指针的来源（一种极端情况，指针是从其他模块传递过来的），而只是把它视为一个有指针类型的整数。所以对于CBaseB类型的指针，取CBaseB的成员变量m_B时，偏移量应该通通为0，这是通过CBaseB的类声明就可以统一决策的事情。

说到这里，pD和pB的指针地址为什么不一样大家应该清楚了，可是为什么下面的代码输出是1呢？

cout << (pD == pB) << endl;

输出1表示pD和pB是相等的，而刚刚我们才说明了，pD和pB的地址是相差了32个字节的。

其实这也是编译器为大家屏蔽了这种指针的差异，当编译器发现一个指向派生类的指针和指向其某个基类的指针进行==运算时，会自动将指针做隐式类型提升已屏蔽多重继承带来的指针差异。因为两个指针做比较，目的通常是判断两个指针是否指向了同一个内存对象实例，在上面的场景中，pD和pB虽然指针值不等，但是他们确确实实都指向了同一个内存对象（即new CDerive;产生的内存对象 ），所以编译器又在此处插了一脚，让我们可以安享==运算的上层语义。

from：http://www.veryhuo.com/a/view/52953.html



《多重继承与类型转换 -- 虚基类多继承》

多重继承是C++的特性之一，但在比较新的Java和C#中被摒弃，因为多重继承在类型转换中会出现一些有意思的现象。

下面是虚方法多重继承

[cpp]  view plain copy
  1. #include <iostream>  
  2. #define interface struct  
  3.   
  4. using namespace std;  
  5.   
  6. interface IA {  
  7.     virtual void FA() = 0;  
  8. };  
  9.   
  10. interface IB {  
  11.     virtual void FB() = 0;  
  12. };  
  13.   
  14. class CA:  
  15.     public IA,public IB  
  16. {  
  17.     virtual void FA()  
  18.     {  
  19.         cout<<"FA"<<endl;  
  20.     }  
  21.     virtual void FB()  
  22.     {  
  23.         cout<<"FB"<<endl;  
  24.     }  
  25. };  
  26.   
  27. int main()  
  28. {  
  29.     CA* pCA = new CA();  
  30.     IA* pIA = static_cast<IA*>(pCA);  
  31.     IB* pIB = static_cast<IB*>(pCA);  
  32.     return 0;  
  33. }  

在程序中加入断点，调试运行，发现pIA的值为0x003a53f8，

而pIB的值为0x003a53fc，也就是说pIB比pIA向后偏移了4个字节

派生类对象指针转换为不同基类对象指针时，编译器会做一些小小的手脚

按照派生类声明的继承顺序，转换为第一基类时指针不变，以后依次向后偏移前一基类所占字节数

这里第一基类IA没有数据成员，偏移量是虚表指针的大小-4字节，

如果有数据成员，还要加上数据成员的大小

注：基于数据对齐原则，在32位系统不足4字节算做4字节

为什么会这样呢？

对于虚方法对象来说，对象开始位置是虚表指针，如果多继承的话

每一个基类都有各自的虚表指针和数据成员，这样派生类对象如何构造呢？

派生类的内存结构如下：

基类A虚表指针 基类A数据成员 基类B虚表指针 基类B数据成员 。。。。。。 派生类数据成员
这样，派生类对象指针在向上转型时，要正确的获取基类的虚方法和数据成员，

只有将指针改变。



《C++多重继承中对函数指针的调整--语言扩充之调整》


代码如下：

[cpp]  view plain copy
  1. class A{  
  2. public:  
  3.     A(){_a = 0x00;}  
  4.     virtual ~A(){}  
  5.     virtual void printA(){}  
  6.     virtual A* clone()const{return NULL;}  
  7.     int _a;  
  8. };  
  9. class B{  
  10. public:  
  11.     B(){_b = 0x11;}  
  12.     virtual ~B(){}  
  13.     virtual void printB(){}  
  14.     virtual B* clone()const{return NULL;}  
  15.     int _b;  
  16. };  
  17. class C:public A, public B{  
  18. public:  
  19.     C(){_c = 0x22;}  
  20.     virtual ~C(){}  
  21.     virtual C* clone()const{return new C;}  
  22.     int _c;  
  23. };  
  24. int _tmain()  
  25. {  
  26.     A a;  
  27.     B b;  
  28.     C c;  
  29.     B* pb = &c;  
  30.     <span style="color:#ff0000;">B* pc = pb->clone();</span>  
  31. }  
这里的关键是clone函数，它的返回值是指向C类型对象的指针，如果要赋给B*指针的话，则返回指针应该加上8，移指向C对象中的B子对象，那这个调整是在哪完成的了？

首先看一下C对象的布局：

__vfptr
_a
__vfptr
_b
_c

红色为C对象中的A子对象，绿色为C对象中的B子对象。

当将c的地址赋给pb时，编译器会将c的地址减8，所以pb实际指向的是绿色部分。

接下来就是进行函数调用了，标红语句会被翻译成如下形式：

(*pb->__vfptr[1])(this);假设clone在虚函数表中的索引为1

由于多态性，该条语句实际要调用的代码是C::clone。所以this的地址是要调整的，在该例中，this需要减8以指向实际的C对象。又因为B：：clone的函数原型，返回值也需要调整，VC通过对虚函数插入一个包装函数来做这些工作。下面是this指针调整的函数：

[thunk]:C::clone`adjustor{8}':这个函数是为了进行this调整为了在给类C的虚函数加的包装
0042EF50  sub         ecx,8 编译器知道在C对象中由第2个基类指针调用时，this指针要上移8个字节
0042EF53  jmp         C::clone (42C31Bh) 

然而，返回值也是需要调整的，因为按B中clone的原型，C::clone的返回值需要+8，所以上面jmp跳转的仍然是一个包装函数：


C::clone:
0042EF60  push        ebp  
0042EF61  mov         ebp,esp 
0042EF63  sub         esp,0D4h 
0042EF69  push        ebx  
0042EF6A  push        esi  
0042EF6B  push        edi  
0042EF6C  push        ecx  
0042EF6D  lea         edi,[ebp-0D4h] 
0042EF73  mov         ecx,35h 
0042EF78  mov         eax,0CCCCCCCCh 
0042EF7D  rep stos    dword ptr es:[edi] 
0042EF7F  pop         ecx  取出this参数
0042EF80  mov         dword ptr [ebp-8],ecx 
0042EF83  mov         ecx,dword ptr [this] 
0042EF86  call        C::clone (42CD43h) 调用函数生成C对象，返回地址在eax中
0042EF8B  mov         dword ptr [ebp-0D0h],eax 这是clone出得C的地址
0042EF91  cmp         dword ptr [ebp-0D0h],0 
0042EF98  je          C::clone+4Bh (42EFABh) 
0042EF9A  mov         eax,dword ptr [ebp-0D0h] 
0042EFA0  add         eax,8 关键点，对返回值进行调整
0042EFA3  mov         dword ptr [ebp-0D4h],eax 
0042EFA9  jmp         C::clone+55h (42EFB5h) 
0042EFAB  mov         dword ptr [ebp-0D4h],0 
0042EFB5  mov         eax,dword ptr [ebp-0D4h] 
0042EFBB  pop         edi  
0042EFBC  pop         esi  
0042EFBD  pop         ebx  
0042EFBE  add         esp,0D4h 
0042EFC4  cmp         ebp,esp 
0042EFC6  call        @ILT+3560(__RTC_CheckEsp) (42CDEDh) 
0042EFCB  mov         esp,ebp 
0042EFCD  pop         ebp  
0042EFCE  ret

ok，通过这两步调整，函数成功调用。

C/C++学习笔记
AnChenliang_1002的博客
04-15 742
函数重载： C++ 允许多个函数拥有相同的名字，只要它们的参数列表不同就可以，这就是函数的重载（Function Overloading）。借助重载，一个函数名可以有多种用途。 参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。 注意，参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。 函数的重载的规则： 函数名称必须相同。 参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。 函数的返回类型
C++多重继承与void*指针转换问题
我不是码农的博客~~~
08-02 805
C++支持多重继承，然而多重继承可能会导致一些奇怪的问题，我前段时间遇到一个指针转换问题，非常典型。 先看一个简单的测试代码： #include <iostream> using namespace std; class IA { public: virtual ~IA(){} virtual void a() = 0; }; class IB { public: virtual ~IB(){} virtual void b() = 0; }; class
C++多继承中指针偏移+四个内置强制类型转换
快乐星球
02-12 2044
话不多说，遇到了就来看下 先看代码 #include "iostream" using namespace std; class Base1 { private: int base1_; }; class Base2 { private: int base2_; }; class Driver :public Base1 , public Base2 { ...
C++多重继承下的指针类型转换
chinabinlang的专栏
07-16 9481
在C++中，指针的类型转换是经常发生的事情，比如将派生类指针转换为基类指针，将基类指针转换为派生类指针。指针的本质其实就是一个整数，用以记录进程虚拟内存空间中的地址编号，而指针的类型决定了编译器对其指向的内存空间的解释方式。 基于上面的理解，我们似乎可以得出一个结论，C++中对指针进行类型转换，不会改变指针的值，只会改变指针的类型(即改变编译器对该指针指向内存的解释方式)，但是这个结论在C+
C++：在多重继承时的指针转换问题
CLN的专栏
04-16 819
原文链接：http://www.chineselinuxuniversity.net/articles/59183.shtml 在C++中，指针的类型转换是经常发生的事情，比如将派生类指针转换为基类指针，将基类指针转换为派生类指针。指针的本质其实就是一个整数，用以记录进程虚拟内存空间中的地址编号，而指针的类型决定了编译器对其指向的内存空间的解释方式。 　　基于上面的理解，我们似乎可以得
C++内存分布 虚表 虚指针(非常重要)
热门推荐
hacker00011000的专栏
05-15 1万+
C++内存分布 虚表 虚指针： class Base { public: int m_base; }; class DerivedA: public Base { public: int m_derivedA; }; class DerivedB: public Base { public: int m_derivedB; }; class D
搞懂C++ 对象的内存布局这一篇就够了（代码图文详解）
weixin_43606861的博客
01-30 705
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。 虚函数表 对C++了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为..
C++基础知识校招面试题，附答案
WYuan的博客
07-01 5648
       本篇博客记录近段时间博主为准备秋招面试收集的C++基础知识面试题。问题后都附上了我自己总结的答案，这个答案可能是书上找的，可能是我自己理解的（所以有错误的地方希望大家能指出来），可能是看了好些博客总结的，可能有的是别人博客里的原话（侵删，请联系我）。        本篇博客会持续更新，后面面试面得越多博客里收集的问题就越多啦。 1、C++为什么要提出引用？        引
《钱能C++第二版》教程及PPT资料
6. 高级特性：异常处理、类型转换操作符、命名空间、多重继承等。 7. 输入输出：C++ I/O流、文件操作和字符串处理。 8. C++新标准：C++11/14/17/20等新版本中加入的语言特性和库函数，例如lambda表达式、智能指针...
C++多重继承子类和父类指针转换过程中的一个易错点
weixin_30342209的博客
10-23 466
这两天有个C++新手问了我一个问题，他的工程当中有一段代码执行不正确，不知道是什么原因。我调了一下，代码如果精简下来，大概是下面这个样子: class IBaseA { public: virtual void fnA() = 0; int m_nTestA; }; class IBaseB { public: virtual void...
多重继承时的指针转换偏移
乔成磊的专栏
12-09 471
 #include using namespace std;class Base{int a;};class Base2{int b;};class Derived :public Base,public Base2{int c;};int main(){ Derived d; Base* p=&d; Base2*p2=&d; c
C++多重继承的指针问题
给永远比拿愉快
05-17 3204
下面说说C++多重继承中关于指针的一些问题。指针指向问题 先看下面的程序：class Base1 { public: virtual void fun1() {cout << "Base1::fun1" << endl;}; };class Base2 { public: virtual void fun2() {cout << "Base2::fun1" << endl;}; }
多重继承与void*指针转换问题的分析
程序人生的专栏
07-03 1096
C++支持多重继承，然而多重继承可能会导致一些奇怪的问题，我前段时间遇到一个指针转换问题，非常典型。 先看一个简单的测试代码： 强制转换为void* 先static_cast再强制转换为void* 先dynamic_cast再强制转换为void* #include using namespace std; class IA { public: virtual ~IA()
C++虚继承和多重继承时的指针类型转换
pgmsoul的专栏
04-05 2218
虚继承会导致子类的大小增加4个字节（VS2008编译器），即使子类没有任何新成员。虚继承加上多重继承，同样又会导致增加4个字节。看下面的示例代码： class WndPtr{ public: int handle; }; class IWnd : public virtual WndPtr{ ; }; class ListBoxPtr : public virtual WndPtr{
多重继承转换二义性
简单生活的专栏
08-31 1069
<br />如果一个类继承多个基类，而且这些基础继承相同的基类，则进行类型转换时，如果转换成相同的父类型，编译时会产生二义性错误：<br /> <br /> class A<br /> { <br />  virtual void test(){} ;<br /> } ;<br /> class B : public A {} ;<br /> class C : public A {} ;<br /> class D: public B, public C {} ;<br /> D *pa = new D(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值