虚函数和虚继承及其在内存中布局

最新推荐文章于 2021-08-07 16:32:40 发布
最新推荐文章于 2021-08-07 16:32:40 发布
阅读量1.5k 收藏
点赞数
分类专栏： C++ 文章标签： class c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fantasywm/article/details/7828744
版权

1.虚函数

一般类的布局

class A
{
public:
    int m_pbl;
protected:
    int m_prt;
private:
    int m_prv;
public:
voidfun() // 不在堆栈中占空间
{
        cout << "It'sfun." << endl;
    }
};

1>  class A   size(12):

1>       +---

1>   0   |m_pbl

1>   4   |m_prt

1>   8   |m_prv

1>       +---

1.1 单个类

1.1.1 单个虚函数

class A
{
public:
    int m_pbl;
protected:
    int m_prt;
private:
    int m_prv;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};

2>  class A   size(16):

2>       +---

2>   0   | {vfptr} // 虚表指针

2>   4   |m_pbl

2>   8   |m_prt

2>  12   |m_prv

2>        +---

2> 

2>  A::$vftable@:// 虚表

2>       | &A_meta

2>        |  0

2>   0   |&A::f1

2> 

2>  A::f1 this adjustor: 0

1.1.2 多个虚函数

class A
{
public:
    int m_pbl;
protected:
    int m_prt;
private:
    int m_prv;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};

1>  class A   size(16):

1>       +---

1>   0   |{vfptr}

1>   4   |m_pbl

1>   8   |m_prt

1>  12   | m_prv

1>       +---

1> 

1>  A::$vftable@: // 同一张表中

1>       | &A_meta

1>       |  0

1>   0   |&A::f1

1>   1   |&A::f2

1> 

1>  A::f1 this adjustor: 0

1>  A::f2 this adjustor: 0

1.2 继承

1.2.1 不加函数

class B : public A
{
};
1>  class B   size(16):

1>  +---

1>  | +--- (baseclass A)

1>   0   | | {vfptr}//同一个指针

1>   4   | |m_pbl

1>   8   | |m_prt

1>  12   | |m_prv

1>   | +---

1>  +---

1> 

1> B::$vftable@: // B的虚表

1>  |&B_meta

1>  |  0

1>   0   |&A::f1

1>   1   |&A::f2

1.2.2 子类override父类的函数

class B : public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};
1>  class B   size(16):

1>       +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_pbl

1>   8   | |m_prt

1>  12   | |m_prv

1>       | +---

1>       +---

1> 

1>  B::$vftable@:

1>       | &B_meta// B用来标识类

1>       |  0

1>   0   | &B::f1 // 变成了B的版本

1>   1   |&A::f2

1> 

1>  B::f1 this adjustor: 0

1.2.3 子类添加虚函数

class B : public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
    void virtual f3()
    {
        cout << "It'sf3." << endl;
    }
};
1>  class B   size(16):

1>  +---

1>  | +---(base class A)

1>   0   | |{vfptr} //合成一个表

1>   4   | |m_pbl

1>   8   | |m_prt

1>  12   | |m_prv

1>  | +---

1>  +---

1> 

1>  B::$vftable@:

1>  |&B_meta

1>  |  0

1>   0   |&B::f1

1>   1   |&A::f2

1>   2   | &B::f3 // 添加到虚表的尾部，类标识为B

1> 

1>  B::f1 this adjustor: 0

1>  B::f3 this adjustor: 0

1.2.4 多继承

class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B
{
public:
    void virtual f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};
class C : public A, public B
{
};

1>  class C   size(12):

1>        +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_data

1>       | +---

1>       | +--- (base class B)

1>   8   | | {vfptr}  // 多个指针

1>       | +---

1>       +---

1> 

1>  C::$vftable@A@:

1>  |&C_meta

1>  |  0

1>   0   |&A::f1

1> 

1>  C::$vftable@B@:

1>  | -8

1>   0   |&B::f1 

1.3 纯虚函数

1.3.1 只在父类

class A
{
private:
    int m_data;
public:
    void virtual f1() = 0;
};
1>  class A   size(8):

1>        +---

1>   0   |{vfptr}

1>   4   | m_data

1>       +---

1> 

1>  A::$vftable@:

1>       | &A_meta

1>       |  0

1>   0   |&A::f1

1> 

1>  A::f1 this adjustor: 0

子类实现

class B : public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};
1>  class B   size(8):

1>       +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_data

1>       | +---

1>       +---

1> 

1>  B::$vftable@:

1>       | &B_meta

1>       |  0

1>   0   | &B::f1

1> 

1>  B::f1 this adjustor: 0 

1.3.2 父类子类都有

class A
{
private:
    int m_data;
public:
    void virtual f1() = 0;
};
class B : public A
{
public:
    void virtual f3() = 0;
};
1>  class B   size(8):

1>       +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_data

1>       | +---

1>       +---

1> 

1>  B::$vftable@:

1>       | &B_meta

1>       |  0

1>   0   |&A::f1

1>   1   |&B::f3

1> 

1>  B::f3 this adjustor: 0

 纯虚函数在内存中布局和一般的虚函数一样。


2.虚继承

2.1 虚继承

class A
{
private:
    int m_data;
};
class B : virtual public A
{
};
1>  class B   size(8):

1>       +---

1>   0   | {vbptr} // 指针

1>       +---

1>       +--- (virtual base A)

1>   4   |m_data

1>       +---

1> 

1>  B::$vbtable@:// 虚继承表

1>   0   | 0

1>   1   | 4(Bd(B+0)A)

1> 

1> 

1>  vbi:       class offset o.vbptr  o.vbte fVtorDisp

1>                 A       4      0       4 0

2.2 两个父类继承自同一个祖父类

2.2.1 没有用虚继承

class A
{
private:
    int m_data;
};
class B :  public A
{
};
class C :  public A
{
};
class D : public B, public C
{
};
1>  class D   size(8):

1>       +---

1>       | +--- (base class B)

1>       | | +--- (base class A)

1>   0   | || m_data

1>       | | +---

1>       | +---

1>       | +--- (base class C)

1>       | | +--- (base class A)

1>   4   | || m_data // 两个m_data

1>       | | +---

1>       | +---

1>       +---

2.2.2 加上虚继承之后

class A
{
private:
    int m_data;
};
class B : virtual public A
{
};
class C : virtual public A
{
};
class D : public B, public C
{
};
1>  class D   size(12):

1>       +---

1>       | +--- (base class B)

1>   0   | |{vbptr}

1>       | +---

1>       | +--- (base class C)

1>   4   | |{vbptr} //添加了两个虚继承的指针

1>       | +---

1>       +---

1>        +--- (virtual base A)

1>   8   | m_data // 只有了一个m_data

1>       +---

1> 

1> D::$vbtable@B@:

1>   0   | 0

1>   1   | 8(Dd(B+0)A)

1> 

1> D::$vbtable@C@:

1>   0   | 0

1>   1   | 4(Dd(C+0)A)

1> 

1> 

1>  vbi:      class  offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      0       4 0

 

3.虚函数和虚继承结合

3.1 一般结合

class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};
1>  class B   size(12):

1>       +---

1>   0   | {vbptr} //虚继承的指针在前

1>       +---

1>       +--- (virtual base A)

1>   4   | {vfptr} // 虚函数的指针在后

1>   8   |m_data

1>       +---

1> 

1>  B::$vbtable@:

1>   0   | 0

1>   1   | 4(Bd(B+0)A)

1> 

1>  B::$vftable@:

1>        | -4

1>   0   |&B::f1

1> 

1>  B::f1 this adjustor: 4

1> 

1>  vbi:      class  offset o.vbptr  o.vbte fVtorDisp

1>                 A       4      0       4 0

3.2 子类中有虚函数

class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
public:
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};

class B  size(16):

1>       +---

1>   0   | {vfptr}

1>   4   | {vbptr}

1>       +---

1>       +--- (virtual base A)

1>   8   | {vfptr} // 2个指针

1>  12   |m_data

1>       +---

1> 

1> B::$vftable@B@:

1>      |&B_meta

1>      |  0

1>   0  | &B::f2

1> 

1>  B::$vbtable@:

1>   0   |-4

1>   1   | 4(Bd(B+4)A)

1> 

1> B::$vftable@A@:

1>  | -8

1>   0  | &A::f1

1> 

1>  B::f2 this adjustor: 0

1> 

1>  vbi:      class offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      4       4 0

这种情况比较特殊，与不是虚继承的类相比，子类单独添加了一个虚表的指针。

若B对f1重写了，则

class B : virtual public A
{
public:
    void f1()
    {
        cout << "It'sf1 int B." << endl;
    }
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};

1>  class B   size(16):

1>       +---

1>   0   |{vfptr}

1>   4   |{vbptr}

1>        +---

1>        +--- (virtual base A)

1>   8   |{vfptr}

1>  12   |m_data

1>       +---

1> 

1>  B::$vftable@B@:

1>       | &B_meta

1>       |  0

1>   0   |&B::f2

1> 

1>  B::$vbtable@:

1>   0   |-4

1>   1   | 4(Bd(B+4)A)

1> 

1>  B::$vftable@A@:

1>       | -8

1>   0   | &B::f1 // f1变成了B的版本

1> 

1>  B::f1 this adjustor: 8

1>  B::f2 this adjustor: 0

1> 

1>  vbi:       class offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      4       4 0

3.3 继承的两个父类继承自同一个祖父类

class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
};
class C : virtual public A
{
};
class D : public B, public C
{
};
1>  class D   size(16):

1>       +---

1>       | +--- (base class B)

1>   0   | |{vbptr}

1>       | +---

1>       | +--- (base class C)

1>   4   | |{vbptr} // 不同类的不同

1>       | +---

1>        +---

1>       +--- (virtual base A)

1>   8   | {vfptr} // 只有一个

1>  12   |m_data

1>       +---

1> 

1>  D::$vbtable@B@:

1>   0   | 0

1>   1   | 8(Dd(B+0)A)

1> 

1>  D::$vbtable@C@:

1>   0   | 0

1>   1   | 4(Dd(C+0)A)

1> 

1>  D::$vftable@:

1>       | -8

1>   0   |&A::f1

1> 

1> 

1>  vbi:        class  offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      0       4 0

3.4 继承的两个父类继承自同一个祖父类并且都有虚函数

class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
public:
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};
class C : virtual public A
{
public:
    void virtual f3()
    {
        cout << "It'sf3." << endl;
    }
};
class D : public C, public B
{
public:
    void virtual f4()
    {
        cout << "It'sf4." << endl;
    }
};
1>  class D   size(24):

1>       +---

1>       | +--- (base class C) // 虚继承C

1>   0   | |{vfptr}

1>   4   | |{vbptr}

1>       | +---

1>        | +--- (base class B) // 虚继承B

1>   8   | |{vfptr}

1>  12   | |{vbptr}

1>       | +---

1>       +---

1>        +--- (virtual base A)

1>  16   |{vfptr}

1>  20   |m_data

1>       +---

1> 

1>  D::$vftable@C@:

1>       | &D_meta

1>       |  0

1>   0   |&C::f3

1>   1   | &D::f4 // 非虚继承则不添加虚表指针，虚函数加到第一个虚表中

1> 

1>  D::$vftable@B@:

1>       | -8

1>   0   |&B::f2

1> 

1>  D::$vbtable@C@:

1>   0   |-4

1>   1   |12 (Dd(C+4)A)

1> 

1>  D::$vbtable@B@:

1>   0   |-4

1>   1   | 4(Dd(B+4)A)

1> 

1>  D::$vftable@A@:

1>       | -16

1>   0   |&A::f1

1> 

1>  D::f4 this adjustor: 0

1> 

1>  vbi:       class offset o.vbptr  o.vbte fVtorDisp

1>                 A      16      4       4 0

fantasywm
关注
专栏目录
虚继承之单继承的内存布局
weixin_30263073的博客
10-10 131
C＋＋2.0以后全面支持虚函数与虚继承，这两个特性的引入为C＋＋增强了不少功能，也引入了不少烦恼。虚函数与虚继承有哪些特性，今天就不记录了，如果能搞了解一下编译器是如何实现虚函数和虚继承，它们在类的内存空间中又是如何布局的，却可以对C＋＋的了解深入不少。这段时间花了一些时间了解这些玩意，搞得偶都，不过总算有些收获，嘿嘿。 先看一段代码class A{ virtual aa(){};};...
虚函数在对象中的内存布局
Lostyears的专栏
03-08 566
典型地，C++通过虚函数实现多态性。多态性的定义：“无论发送消息的对象属于什么类，他们均发送具有相同形式的消息，对消息的处理方式可能随接受消息的对象而变。”具体地说，“在某个基类上建立起来的类的层次结构中，可以对任何一个派生类的对象中的同名成员函数进行调用，而被调用的成员变量所提供的处理可以随其所属的类而改变。”虚函数首先是一种成员函数，它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。
c++虚继承对象的内存布局
09-13 232
备注：转载于http://blog.csdn.net/BlueDog/article/details/4711169 网上关于c++对象布局的文章挺多，而且《深度探索c++对象模型》(Inside The C++ Object Model 侯捷译）一书中也很详细地介绍。
C++ 内存对象布局
11-08
在C++中，对象的内存布局受到多种因素的影响，例如成员变量的类型、是否有虚函数等。接下来我们将详细探讨不同情况下的对象内存布局。 ##### 1. **空类** 空类是指没有任何成员变量的类。尽管此类没有任何成员，但...
c++中虚函数的实现详解
08-31
每个类的对象在其内存布局中都会包含一个隐藏的虚函数指针，这个指针指向对应的虚函数表。当通过基类指针调用虚函数时，编译器会使用这个指针找到相应的虚函数表，然后根据表中的地址调用正确的函数。 以一个简单的...
vf.rar_虚函数
最新发布
09-21
2. **对象初始化**：每个类的对象在创建时，编译器会在对象内存布局中插入一个隐藏的成员，即虚函数表指针（vfptr）。这个指针指向该对象所属类的虚函数表。 3. **虚函数调用**：当我们通过基类指针调用虚函数时，...
虚函数内存模型
06-15
3. **内存布局**：对于含有虚函数的类，对象的内存布局中，虚函数表指针总是位于首位，接着是其他数据成员。 4. **大小计算**：类的大小取决于其数据成员和虚函数表指针的大小，通常虚函数表指针占据4字节（或根据...
C++中包含有虚函数的单继承状态下的类的内存布局
这家伙很懒
11-10 1668
 如下测试代码：#includeiostream>using namespace std;class  base...{    public:    base()    ...{        cout"create base"endl;    };    virtual ~base()    ...{        cout"clean base"endl;    };    virtu
虚继承的内存布局
m0_37313888的博客
03-05 115
下面这个函数的输出结果是什么？ #include<iostream> using namespace std; class A // 4+4 = 8 { public: int a; virtual void p() {} }; class B :virtual public A // 8 + 4 + 4 = 16 { public: int b; virt...
虚继承与内存布局
qq_44777506的博客
02-14 1073
单继承：单个基类 多继承：多个基类 菱形继承： 给出一个基类指针指向派生类对象：B* p=new D(10); 则D的内存布局为： 在图中我们可以看到有两个A的内存块造成了内存重复，浪费了内存，此时就引入了虚继承和虚基类 虚基类：虚继承中的基类 虚继承：加在可能发生内存重复的直接继承上 加上虚继承后，B和C中出现了一个指针，因为指针在编译阶段生成，但是在编译阶段A还未实例化没有地址可以指向，...
【C++】虚函数与虚拟继承的内存布局规则
bale的博客
08-03 1093
在很多面试或口试题中经常涉及到类，而这其中又不得不说类的继承，虚继承，虚函数等问题，所以涉及到了类的内存布局，其中关于虚拟继承（virtual public）这个话题比较难以懂得，而且不同的编译器环境可能实现的类的内存布局不同，所以本文仅在vs2013编译环境下调试，如果你在像gcc这样的编译器中调试结果会不同(gcc中会把虚基指针和虚函数指针合并)。 首先我们要区分虚函数和虚拟继承： 虚拟继承和...
VC++对象布局的奥秘：虚函数、多继承、虚拟继承
IT民工
10-15 4471
即派生类继承多次基类，但在派生类中只存在一份基类的拷贝。编译器实现虚拟继承的方式并不相同，下面我结合VS2010来探讨C++虚拟继承 .VC10的隐含编译项/d1reportSingleClassLayout和/d1reportAllClassLayout 。看个复杂的例子吧(如下)，现在假设我们想知道Derived类的对象布局，怎么办? 在Project Properties->C++->C
C++虚继承对象模型
xsh_123321的专栏
10-21 4229
1.为什么需要虚继承如下图所示如果访问Der::Fun or Der::m_nValue就会带来二义性，无法确定是调用Base1的还是Base2的，所以为了解决多重继承情况下成员访问的二义性，引入了虚继承机制。一般继承                                                                           虚继承2.虚继承实现在虚继承下，Der通过共享虚基类SuperBase来避免二义性，在Base1，Base2中分别保存虚基类指针，Der继承Ba
虚继承内存布局，构造顺序
11-13 330
转自：http://www.cnblogs.com/ziolo/archive/2013/05/07/3066022.html 一直疑惑虚继承与虚函数并存时类的内存结构，下面的文章虽然格式乱但是值得细细品味，我在vs2010下查看了下类的内存结构，除了没有“0x00000000  // 虚基类的非虚基类的分隔符”外，内存结构基本与文中所述一样，另外补充一下虚基类的非虚基类A的偏移地址由8
含有虚函数的内存布局
JingweiZhu
06-25 569
我们来看看有虚函数，并且是有虚基类的类的内存布局 我们看看一个有成员的例子： #include using namespace std; class A{ public:  int a;  A():a(1){}  virtual void show(void){cout }; class B:virtual public A{ public:  int b;  B
虚继承及继承的内存布局
bjzhaoxiao的专栏
05-08 996
1.为什么需要虚继承如下图所示如果访问Der::Fun or Der::m_nValue就会带来二义性，无法确定是调用Base1的还是Base2的，所以为了解决多重继承情况下成员访问的二义性，引入了虚继承机制。一般继承：虚继承：2.虚继承实现在虚继承下，Der通过共享虚基类SuperBase来避免二义性，在Base1，Base2中分别保存虚基类指针，Der继承Base1,Base2,包含Base1...
c++对象模型05：虚继承内存布局
effort_study的博客
08-07 3392
虚继承 虚继承解决了菱形继承中最派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在： 虚继承的派生类，如果定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。（非虚继承时，派生类新的虚函数直接扩展在基类虚函数表的下面。） 虚继承的派生类有单独的虚函数表，基类也有单独的虚函数表，两部分之间用一个四个字节的0x00000000来作为分界。 虚继承的派生类对象中，含有四字节的虚基表指针。 在C++对象模型中，虚继承而
C++虚函数详解：虚表与对象内存布局
"C++虚函数实现机制及其在内存布局中的应用" C++中的虚函数是实现多态性的重要工具，这种动态绑定机制使得程序能够通过基类指针或引用调用派生类重写的成员函数。虚函数的核心在于虚函数表（Virtual Table，简称...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值