怎么计算C++继承 虚函数类 虚继承

最新推荐文章于 2022-10-23 22:04:07 发布
最新推荐文章于 2022-10-23 22:04:07 发布
阅读量342 收藏
点赞数


真空类
C++代码
class CNull  
{  
  
}; 

　　长度：1
　　内存结构：
　　??
　　评注：长度其实为0，这个字节作为内容没有意义，可能每次都不一样。
　　二、空类
C++代码
class CNull2  
{  
public:  
　　CNull2(){printf("Construct/n");}  
　　~CNull2(){printf("Desctruct/n");}  
　　void Foo(){printf("Foo/n");}  
}; 

　　长度：1
　　内存结构：
　　??
　　评注：同真空类差不多，内部的成员函数并不会影响类大小。
　　三、简单类
C++代码
class COneMember  
{  
public:  
    COneMember(int iValue = 0){m_iOne = iValue;};  
private:  
    int m_iOne;  
}; 

　　长度：4
　　内存结构：
　　00 00 00 00 //m_iOne
　　评注：成员数据才影响类大小。
　　四、简单继承
C++代码
class CTwoMember:public COneMember  
{  
private:  
    int m_iTwo;  
}; 

　　长度：8
　　内存结构：
　　00 00 00 00 //m_iOne
　　CC CC CC CC //m_iTwo
　　评注：子类成员接在父类成员之后。
　　五、再继承
C++代码
class CThreemember:public CTwoMember  
{  
public:  
    CThreemember(int iValue=10) {m_iThree = iValue;};  
private:  
    int m_iThree;  
}; 

　　长度：12
　　内存结构：
　　00 00 00 00 //m_iOne
　　CC CC CC CC //m_iTwo
　　0A 00 00 00 //m_iThree
　　评注：孙类成员接在子类之后，再再继承就依此类推了。
　　六、多重继承
C++代码
class ClassA  
{  
public:  
    ClassA(int iValue=1){m_iA = iValue;};  
private:  
    int m_iA;  
};  
  
class ClassB  
{  
public:  
    ClassB(int iValue=2){m_iB = iValue;};  
private:  
    int m_iB;  
};  
  
class ClassC  
{  
public:  
    ClassC(int iValue=3){m_iC = iValue;};  
private:  
    int m_iC;  
};  
  
class CComplex :public ClassA, public ClassB, public ClassC  
{  
public:  
    CComplex(int iValue=4){m_iComplex = iValue;};  
private:  
    int m_iComplex;  
}; 

　　长度：16
　　内存结构：
　　01 00 00 00  //A
　　02 00 00 00  //B
　　03 00 00 00  //C
　　04 00 00 00  //Complex
　　评注：也是父类成员先出现在前边，我想这都足够好理解。
　　七、复杂一些的继承
　　不写代码了，怕读者看了眼花，改画图。

　　长度：32
　　内存结构：
　　01 00 00 00 //A
　　02 00 00 00 //B
　　03 00 00 00 //C
　　04 00 00 00 //Complex
　　00 00 00 00 //OneMember
　　CC CC CC CC //TwoMember
　　0A 00 00 00 //ThreeMember
　　05 00 00 00 //VeryComplex
　　评注：还是把自己的成员放在最后。
　　只要没涉及到“虚”（Virtual），我想没什么难点，不巧的是“虚”正是我们要研究的内容。
　　八、趁热打铁，看“虚继承”
C++代码
class CTwoMember:virtual public COneMember  
{  
private:  
    int m_iTwo;  
}; 

　　长度：12
　　内存结构：
　　E8 2F 42 00 //指针，指向一个关于偏移量的数组，且称之虚基类偏移量表指针
　　CC CC CC CC // m_iTwo
　　00 00 00 00 // m_iOne（虚基类数据成员）
　　评注：virtual让长度增加了4，其实是多了一个指针，关于这个指针，确实有些复杂，别的文章有具体分析，这里就不岔开具体讲了，可认为它指向一个关于虚基类偏移量的数组，偏移量是关于虚基类数据成员的偏移量。
　　九、“闭合”虚继承，看看效果

　　长度：24
　　内存结构：
　　14 30 42 00 //ClassB的虚基类偏移量表指针
　　02 00 00 00 //m_iB
　　C4 2F 42 00 //ClassC的虚基类偏移量表指针
　　03 00 00 00 //m_iC
　　04 00 00 00 //m_iComplex
　　01 00 00 00 //m_iA
　　评注：和预料中的一样，虚基类的成员m_iA只出现了一次，而且是在最后边。当然了，更复杂的情况要比这个难分析得多，但虚继承不是我们研究的重点，我们只需要知道：虚继承利用一个“虚基类偏移量表指针”来使得虚基类即使被重复继承也只会出现一次。
　　十、看一下关于static成员
C++代码
class CStaticNull  
{  
public:  
    CStaticNull(){printf("Construct/n");}  
    ~CStaticNull(){printf("Desctruct/n");}  
    static void Foo(){printf("Foo/n");}  
    static int m_iValue;  
}; 

　　长度：1
　　内存结构：（同CNull2）
　　评注：可见static成员不会占用类的大小，static成员的存在区域为静态区，可认为它们是“全局”的，只是不提供全局的访问而已，这跟C的static其实没什么区别。
　　十一、带一个虚函数的空类
C++代码
class CVirtualNull  
{  
public:  
    CVirtualNull(){printf("Construct/n");}  
    ~CVirtualNull(){printf("Desctruct/n");}  
    virtual void Foo(){printf("Foo/n");}  
}; 

　　长度：4
　　内存结构：
　　00 31 42 00 //指向虚函数表的指针（虚函数表后面简称“虚表”）
　　00423100:（虚表）
　　41 10 40 00 //指向虚函数Foo的指针
　　00401041:
　　E9 78 02 00 00 E9 C3 03 … //函数Foo的内容（看不懂）
　　评注：带虚函数的类长度就增加了4，这个4其实就是个指针，指向虚函数表的指针，上面这个例子中虚表只有一个函数指针，值就是“0x00401041”，指向的这个地址就是函数的入口了。
　　十二、继承带虚函数的类
C++代码
class CVirtualDerived : public CVirtualNull  
{  
public:  
    CVirtualDerived(){m_iVD=0xFF;};  
    ~CVirtualDerived(){};  
private:  
    int m_iVD;  
}; 

　　长度：8
　　内存结构：
　　3C 50 42 00 //虚表指针
　　FF 00 00 00 //m_iVD
　　0042503C:（虚表）
　　23 10 40 00 //指向虚函数Foo的指针，如果这时候创建一个CVirtualNull对象，会发现它的虚表的内容跟这个一样
　　评注：由于父类带了虚函数，子类就算没有显式声明虚函数，虚表还是存在的，虚表存放的位置跟父类不同，但内容是同的，也就是对父类虚表的复制。
　　十三、子类有新的虚函数
C++代码
class CVirtualDerived: public CVirtualNull  
{  
public:  
    CVirtualDerived(){m_iVD=0xFF;};  
    ~CVirtualDerived(){};  
    virtual void Foo2(){printf("Foo2/n");};  
private:  
    int m_iVD;  
}; 

　　长度：8
　　内存结构：
　　24 61 42 00 //虚表指针
　　FF 00 00 00 //m_iVD
　　00426124:（虚表）
　　23 10 40 00
　　50 10 40 00
　　评注：虚表还是只有一张，不会因为增加了新的虚函数而多出另一张来，新的虚函数的指针将添加在复制了的虚表的后面。
　　十四、当纯虚函数（pure function）出现时
C++代码
class CPureVirtual  
{  
    virtual void Foo() = 0;  
};   
  
class CDerivePV : public CPureVirtual  
{  
    void Foo(){printf("vd: Foo/n");};  
}; 

　　长度：4（CPureVirtual），4（CDerivePV）
　　内存结构：
　　CPureVirtual:
　　（不可实例化）
　　CDerivePV:
　　28 50 42 00 //虚表指针
　　00425028:（虚表）
　　5A 10 40 00 //指向Foo的函数指针
　　评注：带纯虚函数的类不可实例化，因此列不出其“内存结构”，由其派生类实现纯虚函数。我们可以看到CDerivePV虽然没有virtual声明，但由于其父类带virtual，所以还是继承了虚表，如果CDerivePV有子类，还是这个道理。
　　十五、虚函数类的多重继承
　　前面提到：（子类的虚表）不会因为增加了新的虚函数而多出另一张来，但如果有多重继承的话情况就不是这样了。下例中你将看到两张虚表。

　　大小：24
　　内存结构
　　F8 50 42 00 //虚表指针
　　01 00 00 00 //m_iA
　　02 00 00 00 //m_iB
　　E8 50 42 00 //虚表指针
　　03 00 00 00 //m_iC
　　04 00 00 00 //m_iComplex
　　004250F8:（虚表）
　　5A 10 40 00 //FooA
　　55 10 40 00 //FooB
　　64 10 40 00 //FooComplex
　　004250E8:（虚表）
　　5F 10 40 00 //FooC
　　评注：子类的虚函数接在第一个基类的虚函数表的后面，所以B接在A后面，Complex接在B后面。基类依次出现，子类成员接在最后面，所以m_iComplex位于最后面。
　　十六、包含虚函数类的虚继承
C++代码
class VirtualInheritance  
{  
    char k[3];  
public:  
    virtual void aa(){};  
};  
class sonClass1: public virtual VirtualInheritance  
{  
    char j[3];  
public:  
    virtual void bb(){};  
};  
class sonClass2: public virtual sonClass1  
{  
    char f[3];  
public:  
    virtual void cc(){};  
};  
  
int main()  
{  
    cout << "sizeof(VirtualInheritance):" << sizeof(VirtualInheritance) << endl;  
    cout << "sizeof(sonClass1):" << sizeof(sonClass1) << endl;  
    cout << "sizeof(sonClass2):" << sizeof(sonClass2) << endl;  
  
    return 0;  
} 

　　输出的结果：
　　visio studio： 8，20，32
　　gcc： 8，16，24
　　评注：
　　对于VirtualInheritance类，大小为8， 没有异议，他有个虚表指针vtp_VirtualInheritanc;
　　对于sonClass1类：
　　在visio studio 编译器下，大小为20。由于是虚拟继承，又有自己的虚函数，所以先拥有一个自己的虚函数指针vpt_sonClass1，大小为4，指向自己的虚表；还要有一个char[3]，大小为4；为了实现虚拟继承，首先sonClass1加入了一个指向其父类的虚类指针，记作vtp_sonClass1_VirtualInheritanc，大小为4；然后在加上父类的所有大小8，所以总共是20字节。
　　在gcc编译器下，大小为16，没有计算子类中指向父类的虚类指针vtp_sonClass1_VirtualInheritanc的大小。
　　对于sonClass2：
　　在visio studio环境下，大小为32。和上面一样，子类拥有char[3]，大小为4字节，因为是虚继承，还有自己的虚函数，所以拥有自己的一个虚表指针，vtp_sonClass2，大小为4字节。然后还有一个指向父类的虚类指针vtp_sonClass2_sonClass
　　1，大小为4。最后加上其父类的总大小20，所以总的大小为4+4+4+20=32；
　　在gcc环境下，没有计算虚类指针的大小，即4+4+16=24。
　　17、包含虚函数的多重普通、虚拟混合继承
C++代码
class VirtualInheritance  
{  
    char k[3];  
public:  
    virtual void aa(){};  
};  
class sonClass1: public virtual VirtualInheritance  
{  
    char j[3];  
public:  
    virtual void bb(){};  
};  
  
class VirtualInheritance2  
{  
    char l[3];  
public:  
    virtual void dd(){};  
};  
  
class sonClass2: public virtual sonClass1,public VirtualInheritance2  
{  
    char f[3];  
public:  
   virtual void cc(){};  
};  
  
int main()  
{  
    cout << "sizeof(VirtualInheritance):" << sizeof(VirtualInheritance) << endl;  
    cout << "sizeof(sonClass1):" << sizeof(sonClass1) << endl;  
    cout << "sizeof(sonClass2):" << sizeof(sonClass2) << endl;  
  
    return 0;  
} 

　　评注：此时sonClass2的大小变成36。和16不同的是，此时sonClass2是多重继承，其中一个是虚继承，一个普通继承，他的大小在visio studio中变成36，相比16增加了4，这刚好是char l[3]的大小，因为耸sonClass2已经有了一个虚表，所以在他原有的虚表中多一条记录即可。
　　18、包含虚函数的多重虚拟继承
C++代码
class VirtualInheritance  
{  
    char k[3];  
public:  
    virtual void aa(){};  
};  
class sonClass1: public virtual VirtualInheritance  
{  
    char j[3];  
public:  
    virtual void bb(){};  
};  
  
class VirtualInheritance2  
{  
    char l[3];  
public:  
    virtual void dd(){};  
};  
  
class sonClass2: public virtual sonClass1,public virtual VirtualInheritance2  
{  
    char f[3];  
public:  
   virtual void cc(){};  
};  
  
int main()  
{  
    cout << "sizeof(VirtualInheritance):" << sizeof(VirtualInheritance) << endl;  
    cout << "sizeof(sonClass1):" << sizeof(sonClass1) << endl;  
    cout << "sizeof(sonClass2):" << sizeof(sonClass2) << endl;  
  
    return 0;  
} 

　　评注：此时sonClass2的大小变成40。与17不同的是，sonClass2的多重继承都是虚拟继承。sonClass2的大小由以下几部分构成：
　　1.自己本身的大小，char[3] 大小为4，一个虚函数，所以有个指向虚表的指针，大小为4，所以自身大小总的为8；
　　2.虚拟继承sonClass1，因为虚拟继承所以有个虚类指针ptr_sonClass2_sonClass1，大小为4，而sonClass1的大小为20，所以虚拟继承sonClass1的大小为24；
　　3.虚拟继承VirtualInheritance2，一个虚类指针ptr_sonClass2_VirtualInheritance2=ptr_sonClass2_sonClass1+偏移量，该指针和ptr_sonClass2_sonClass1公用一个指针，只是偏移量不同，所以大小为0（即使再多继承几个virtual class，这个指针的大小只算 一次），而VirtualInheritance2的大小为8，所以总的大小为8。
　　所以40=8+24+8
　　总结：
　　1，普通单继承，只需将自身成员变量的大小加上父类大小（父类中 有虚函数，子类中不管有没有）若父类没有虚函数，则子类大小需要加上指向虚表的指针大小。
　　2，普通多继承，若几个父类都有虚表，则子类与第一个父类公用一个虚表指针，其他有几个有虚函数的父类则就有几个虚表指针。
　　3，虚拟单继承，此时若子类有虚函数则加上一个自身的虚表指针的大小，（若没有则不加）再加上自身的成员变量大小，还要加上一个虚类指针ptr_sonclass_fatherclass，最后加上父类的大小。
　　4，多重虚拟继承，此时若子类有虚函数则加上一个自身的虚表指针的大小，（若没有则不叫）再加上自身的成员变量大小，还要加上 一个公用的虚类指针（不管有几个虚拟父类，只加一个），在加上所有父类的大小。
　　5、普通、虚拟混合多继承，此时子类的大小为自身大小（若子类或普通父类有虚函数，则为成员变量+虚表指针大小；若都没虚函数，则就为成员变量大小），加上一个虚类指针大小，在加上虚拟父类的大小，在加上普通父类的大小（除虚表指针，因为它和子类公用一个虚表指针）。
　　欢迎补充！
本文来源于鸡啄米 http://www.jizhuomi.com/ , 原文地址：http://www.jizhuomi.com/software/374.html

 

yishuige
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
怎样计算C++继承、虚继承、虚函数类的大小
hyqsong的专栏
03-09 465
点击查看详细解释
C++(虚)继承类的内存占用大小
落枫的专栏
02-21 1792
首先，平时所声明的类只是一种类型定义，它本身是没有大小可言的。 因此，如果用sizeof运算符对一个类型名操作，那得到的是具有该类型实体的大小。 计算一个类对象的大小时的规律： 1、空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）； 2、一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的； 3、因此一个对象的大小
【整理】C++虚函数及其继承、虚继承类大小
weixin_30482181的博客
07-07 211
参考文章： http://blog.chinaunix.net/uid-25132162-id-1564955.html http://blog.csdn.net/haoel/article/details/1948051/ 一、虚函数与继承 1、空类，空类单继承，空类多继承的sizeof #include <iostream> using namespace ...
C++虚函数表分析
weixin_30443747的博客
07-26 137
先看代码： #include <iostream> using namespace std; class Base { public: virtual void f() {cout<<"base::f"<<endl;} virtual void g() {cout<<"base::g"<<endl;...
C++类对象大小的计算(三)含有虚函数、虚继承类大小计算
日积月累
10-01 2247
前一篇文章《C++类对象大小的计算(一)常规类大小计算》初步介绍类大小计算后，我们继续来讨论含有虚函数时类的大小。
C++类的虚函数虚继承所占的空间
12-22
　GCC中， 无论是虚函数还是虚继承， 都需要将指针存储在虚函数表(virtual function table)， 占用4个字节. 　继承会继承基类的数据， 和虚函数表， 即继承基类的空间. 　代码: /* * test.cpp * * Created ...
类继承与虚函数.ppt
02-15
3虚函数;4类类型之间的强制转换;5嵌套类 1.封装: 把对象的属性和方法结合成一个独立的系统单位，并尽可能隐藏对象的内部细节。 2.继承: 子类对象拥有与其基类相同的全部属性和方法。 例如人都共有的一些属性：...
C++ 虚继承对基类构造函数调用顺序的影响
01-20
继承作为面向对象编程的一种基本特征，其使用频率... 　假设derived 虚继承自base类，那么derivd与base是一种“has a”的关系，即derived类有一个指向base类的vptr。（貌似有些牵强！某些编译器确实如此） 　因此虚
C++虚函数实现机制以及类继承中的内存分布
12-22
c++为了兼容c保留了struct类型，但是c++中的struct和c有明显的区别，c++中的struct可以继承，可以有成员函数，但是在c中却不行，在c++中struc和class更相似（还是有一些区别的，这里不再叙述），c中struct的内存分布...
解析C++编程中virtual声明的虚函数以及单个继承
09-02
在C++中，派生类可以继承基类的所有公有和受保护成员，包括虚函数。在上述代码中，`CheckingAccount`和`SavingsAccount`都继承自`Account`，因此它们都拥有`Account`类的`GetBalance()`和`PrintBalance()`这两个虚...
C++虚函数表的验证
gerryke的blog
08-12 551
要了解C++对象的虚函数的内存布局，推荐的是如下的三篇由浅入深的文章： C++虚函数表解析 http://blog.csdn.net/haoel/article/details/1948051 C++对象的内存布局（上） http://blog.csdn.net/haoel/article/details/3081328 C++对象的内存布局（下） http://b
C++中虚函数继承类的内存占用大小计算
时间溜走了的博客
06-16 930
计算一个类对象的大小时的规律： 1、空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）； 2、一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的； 3、因此一个对象的大小≥所有非静态成员大小的总和； 4、当类中声明了虚函数（不管是1个还是多个），那么在实例化对象时，编译器会自动在对象里安插一个指针vPtr指向虚函数表VTable； 5、虚承继的情况：由于涉及到虚函数表和虚基表，会同时增加一个（多重虚继承下对应多个）vfPtr指针指向虚函数
【c++】虚函数（二）——虚函数表的验证
师兄怎么办
07-11 325
在上篇博文中，类中的首地址多出来四个字节 以下将验证多出来的的四个字节究竟是不是虚函数表。 ————————————下面是正文—————————————— 在验证之前，首先来补充一些知识：函数指针 根据我以前写的一篇《【c语言】带你真正走进指针的世界——函数指针》中可以得知：函数名就是函数的指针，代表了函数的真实地址。以下为函数指针的简单运用： ...
C++类的大小及虚函数表
chuncanL的博客
04-20 2142
之前用C的时候，停挺经常计算结构体空间的，现在突然用C++了，好像还不知道C++类大小怎么算的。 1. 类的组成我也不知道这么说是否正确，我觉得类主要有两类成员：数据成员，成员函数，并且 * 数据成员有静态和非静态之分 * 函数成员有静态，非静态和虚函数(virtual)之分 数据成员 在C++类中，数据成员的初始化是按照类中声明的先后顺序初始化，而与函数参数的传入顺序没有关系
C++中虚函数工作原理和(虚)继承类的内存占用大小计算【转】
youtiao_hulatang的博客
03-05 273
一、虚函数的工作原理 虚函数的实现要求对象携带额外的信息，这些信息用于在运行时确定该对象应该调用哪一个虚函数。典型情况下，这一信息具有一种被称为 vptr（virtual table pointer，虚函数表指针）的指针的形式。vptr 指向一个被称为 vtbl（virtual table，虚函数表）的函数指针数组，每一个包含虚函数的类都关联到 vtbl。当一个对象调用了虚函数，实际...
C++虚函数表
最新发布
weixin_48984572的博客
10-23 367
虚函数表，虚函数
c++ 空类，含有虚函数的类的大小
yhc166188的博客
07-22 3304
1、为何空类的大小不是0呢？ 为了确保两个不同对象的地址不同，必须如此。 类的实例化是在内存中分配一块地址，每个实例在内存中都有独一无二的二地址。同样，空类也会实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化后就有独一无二的地址了。所以，空类的sizeof为1，而不是0. 2、请看下面的类： class A{ virtual void f(){} }; class B:pub...
C++关于空类型大小以及存在虚函数大小
雨时水滴猿先晓的博客之家
01-16 357
废话少说，直接上代码 #include<iostream> using namespace std; class A{ }; class B{ B(){} ~B(){} }; class C{ C(){} virtual ~C(){} }; int main(){ cout<<"A的...
C++虚继承下带有虚函数的类的大小（含多重虚继承，虚继承后完全覆盖等复杂情况）
chczy1的博客
08-20 947
带有虚函数的虚继承的对象模型比较复杂，所以来整理一下。以下讨论均在visual studio2017以及64位环境的前提下进行； 1.带有虚函数的类 class A { public: int a_; virtual void foo1() { cout << "A1" << endl; } virtual void foo2() { cout <<...
C++ 类继承与虚函数详解：类型转换与友元
总结来说，类型转换函数、类继承、虚函数和友元都是C++中重要的面向对象特性，它们各自服务于不同的目的，帮助开发者构建更加灵活和强大的程序结构。在实际编程中，应当谨慎使用友元，充分利用继承和虚函数来实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值