sizeof 类 2

#include<iostream>
using namespace std;

class C1
{
 int a;
};
class C1_none
{
};
class C2
{
 int b;
};
class C3
{
};
class C4
{
};
class C5:virtual C3,virtual C4
{
};
class C6:virtual C1,virtual C2,virtual C3,virtual C4
{
};
class C7:virtual C1_none,virtual C2,virtual C3,virtual C4
{
};
class A
{
 virtual void a()
 {
 }
};
class A1
{
 virtual void a()
 {
 }
};
class B0:public A,public A1
{
};
class B1:virtual A,virtual A1
{
};
class B2:virtual A,public A1
{
};
class B3:public A,public A1
{
 void a();
};
class CommonBase1
{
 int co;
};
class CommonBase2
{
public:
 virtual void print1(){}
 virtual void print2(){}
 virtual void dump1(){}
 virtual void dump2(){}
 int co;
};
class Base1:virtual public CommonBase1
{
public:
 virtual void print1(){}
 virtual void print2(){}
private:
 int b1;
};
class Base2:virtual public CommonBase1
{
public:
 virtual void dump1(){}
 virtual void dump2(){}
private:
 int b2;
};
class Base3:virtual public CommonBase2
{
public:
 virtual void print1(){}
 virtual void print2(){}
private:
 int b1;
};
class Base4:virtual public CommonBase2
{
public:
 virtual void dump1(){}
 virtual void dump2(){}
private:
 int b2;
};
class Derived1:public Base1,public Base2
{
public:
 void print2(){}
 void dump2(){}
private:
 int d;
};
class Derived2:virtual public Base1,virtual public Base2
{
public:
 void print2(){}
 void dump2(){}
private:
 int d;
};
class Derived3:public Base3,public Base4
{
public:
 void print2(){}
 void dump2(){}
private:
 int d;

};
class Derived4:virtual public Base3,virtual public Base4
{
public:
 void print2(){}
 void dump2(){}
private:
 int d;
};
int main(int argc,char *argv[])
{
 cout<<"sizeof(C5):"<<sizeof(C5)<<endl;
 cout<<"sizeof(C6):"<<sizeof(C6)<<endl;
 cout<<"sizeof(C7):"<<sizeof(C7)<<endl;
 cout<<"sizeof(B0):"<<sizeof(B0)<<endl;
 cout<<"sizeof(B1):"<<sizeof(B1)<<endl;
 cout<<"sizeof(B2):"<<sizeof(B2)<<endl;
 cout<<"sizeof(B3):"<<sizeof(B3)<<endl;
 cout<<"sizeof(Base1):"<<sizeof(Base1)<<endl;
 cout<<"sizeof(Base2):"<<sizeof(Base2)<<endl;
 cout<<"sizeof(Base3):"<<sizeof(Base3)<<endl;
 cout<<"sizeof(Base4):"<<sizeof(Base4)<<endl;
 cout<<"sizeof(Derived1):"<<sizeof(Derived1)<<endl;
 cout<<"sizeof(Derived2):"<<sizeof(Derived2)<<endl;
 cout<<"sizeof(Derived3):"<<sizeof(Derived3)<<endl;
 cout<<"sizeof(Derived4):"<<sizeof(Derived4)<<endl;
 return 0;
}

结果如下：

sizeof(C5):4
sizeof(C6):12
sizeof(C7):8
sizeof(B0):8
sizeof(B1):8
sizeof(B2):8
sizeof(B3):8
sizeof(Base1):12
sizeof(Base2):12
sizeof(Base3):16
sizeof(Base4):16
sizeof(Derived1):24
sizeof(Derived2):28
sizeof(Derived3):28
sizeof(Derived4):32

实验环境为Ubuntu12.04 LTS 32位的。

总结一下自己了解到的知识：

有虚函数的类都会自动的产生一个指向虚函数表的指针。（多态的实现就是利用虚函数表，对于每个类都新建一个虚函数表，该表包含自己的虚函数，还有父类的虚函数，如果子类函数覆盖父类函数的话就把函数指针指向子类里的函数。从而每个指向子类的基类指针调用函数时其实使用的是子类的虚函数表查找函数指针，自然就实现了多态了）。

虚继承是多继承时为了解决父类二意性而产生的继承方法。虚继承的子类中还包含一个指向父类的指针（即指向虚基表的指针）。

我自己先分析一下：

首先，很显然，C1，C1_none，C2，C3，C4的大小都是4，（要么为空，要么只有一个int成员变量）

C5，C6，C7都是自己拥有的成员变量的大小加上4，但是这个4是什么就不了解了（指向虚基表的指针？？？）

A和A1的大小都是4，都包含一个指向虚函数表的指针。

B0，B1，B2，B3都是8，其中，应该都有一个指向虚函数表的指针，大小为4，剩下的4是什么就不了解了（指向虚基表的指针？？？）

CommonBase1和CommonBase2分别为4和8，一个有虚函数表的指针，一个没有。

Base1和Base2都是12，分别是父类的成员变量和子类的成员变量和指向虚函数表的指针

Base3和Base4都是16，比Base1和Base2多了4，不甚了解这个4是什么（又是指向虚集表的指针？？？）

Derived1的大小是24，应该是父类和子类中的四个int成员变量和一个指向虚函数表的指针，剩下的4不知道（又是指向续基表的指针？？？还是因为没有虚继承，所以commonBase的成员变量计算了两次？？？）

Derived2的大小是28，所以应该是四个int成员变量，一个指向虚函数表的指针，（两个指向虚基表的指针？？？）

Derived3大大小是28，四个int成员变量，一个指向虚函数表的指针，

Derived4的大小是32，四个int成员变量+虚函数表的指针+？？？

求大家帮忙分析啊…… 多继承和虚继承搞晕了。

下面是几个规则，供参考：

    1、空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）；
    2、一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的；
    3、因此一个对象的大小≥所有非静态成员大小的总和；
    4、当类中声明了虚函数（不管是1个还是多个），那么在实例化对象时，编译器会自动在对象里安插一个指针vPtr指向虚函数表VTable；
    5、虚承继的情况：由于涉及到虚函数表和虚基表，会同时增加一个（多重虚继承下对应多个）vfPtr指针指向虚函数表vfTable和一个vbPtr指针指向虚基表vbTable，这两者所占的空间大小为：8（或8乘以多继承时父类的个数）；
    6、在考虑以上内容所占空间的大小时，还要注意编译器下的“补齐”padding的影响，即编译器会插入多余的字节补齐；
    7、类对象的大小=各非静态数据成员（包括父类的非静态数据成员但都不包括所有的成员函数）的总和+ vfptr指针(多继承下可能不止一个)+vbptr指针(多继承下可能不止一个)+编译器额外增加的字节。

本篇文章来源于 Linux公社网站(www.linuxidc.com)  原文链接：http://www.linuxidc.com/Linux/2012-12/75897p2.htm