大小测试（空类、带含静态和非含、虚和非虚的单继承和多继承等）

本文主要是测试类大小，包括空类、带静态和不静态变量的、虚和非虚的单继承和多继承类，及类或对象的

虚表及虚指针是否相同等情况的测试，并给出简单的解释，有不当的地方，敬请指出，一起交流与进步！

/********************************************************************

** 创建人: 蔡国武

** 日 期: 2009/5/22 15:31

** 版 本: 1.0

** 描 述: 测试类的大小并解释原因: 空类、带静态或虚表的类、继承和虚继承等测试

结论：

1： 空类的大小为1，不是0; 原因很简单，存在的，就一定会占空间。

2： 虚表和虚函数：一个类对应一个虚表，每个对象含有一个虚函数指针（_vptr）指向虚表。

3： 验证了：虚继承及嵌套虚继承是否也可以共享内存的机制等测试

** 应 用:

**************************** 修改记录******************************

** 修改人:

** 日 期:

** 描 述:

********************************************************************/

namespace testSizeOfClass

{

//////// 测试类的大小start ////////

class CEmptyClass

{

};

// sizeof(CEmptyClass) = 1 ==》空类的大小为1，不是0; 原因很简单，存在的，就一定会占空间。

class A

{

virtual void a(){}

};

// sizeof(A) = 4 // 带虚的类，因为有虚表指针，所以要占用4个字节

class A1

{

virtual void a(){}

};

// sizeof(A1) = 4 // 带虚的类，因为有虚表指针，所以要占用4个字节

class A2

{

static int m_sNum;

};

// sizeof(A2) = 1 // ==》静态变量不属于某个类，是共用的

class A3

{

virtual void a(){}

static int m_sNum;

};

// sizeof(A3) = 4 // ==》静态变量不属于某个类，但虚指针要占用4个字节

class A4

{

bool m_bValue;

int m_nValue;

static int m_sNum;

};

// sizeof(A4) = 8 // 注意：内存对齐

class B : public A

{

};

// sizeof(B) = 4

class B1 : virtual public A // 单虚继承

{

};

// sizeof(B2) = 8 // 注意：虚继承增加了一个虚指针

// 如果不考滤虚多继承：

// 由B 和B1的大小 ，==》虚继承比非虚继承大4个字节，这多出的，其实也是个虚指针，暂节不考滤，继续往下测试

class B2 : public A，public A1 // 多继承 父类都是带虚类

{

};

// sizeof(B2) = 4

class B3 : public A1，public A2 // 多继承 父类只有一个带虚类

{

};

// sizeof(B3) = 4 // 注意：虚继承增加了一个虚指针

// 如果不考滤虚多继承：

// 由B、B2和B3的大小 ，==》那么一个类只有一个虚表，与多继承无关，一个对象只对应一个虚指针

// 下面继续测试，虚多继承的情况

class B4 : public A，virtual public A1 // 多继承, 单虚继承

{

};

// sizeof(B4) = 12 // 12 = sizeof(A) + sizeof(A1) + 虚继承一个虚表指针= 4 + 4 + 4

class B5 : public virtual A ，virtual public A1 // 都是虚继承

{

};

// sizeof(B5) = 12 // 12 = sizeof(A) + sizeof(A1) + 虚继承一个虚表指针= 4 + 4 + 4

// 虚多继承：

// 由B4和B5的大小 ，==》只要是虚继承，单个和多个虚继承，都只增加4个字节，也就是一个虚表指针

//class C : public A1, virtual public A1 // 出错，同一个类只能只有一种继承方式

//{

//};

class C1 : public B, virtual public A

{

};

// sizeof(C) = 12

class C2 : public B1, virtual public A

{

};

// sizeof(C2) = 8 // 注意：虚继承可以共享内存，所以class C2 : public B1, virtual public A 相当于class C2 : public B1

class C3 : public B1 // 验证：虚继承可以共享内存的机制， 因为B1 已经 虚继承A

{

};

// sizeof(C3) = 8 // 注意：虚继承可以共享内存的机制

class C4 : virtual public B1 // 因为B1 已经 虚继承A

{

};

// sizeof(C4) = 12 // 注意：虚继承可以共享内存的机制

// 验证：虚继承嵌套是否也可以共享内存的机制，因为virtual B1的 虚指针也指向自身 已经 虚继承的A

class C5 : virtual public B1, virtual public A

{

};

// sizeof(C5) = 12 // 注意：虚继承可以共享内存，所以class C2 : public virtual B1, virtual public A 相当于class C2 : virtual public B1

/////// 测试类的大小end ////////

void testSizeof(void)

{

A a1,a2;

// 相同类的不同对象的虚表指针vptr 都是相同的,测试如下

if (&a1 == &a2) // 这是成立

{

cout<<"相同类的不同对象的虚表指针vptr 都是相同的";

}

else

{

cout<<"相同类的不同对象的虚表指针vptr 是不相同的";

}

int nSizeof;

CEmptyClass

nSizeof = sizeof(CEmptyClass);

nSizeof = sizeof(A);

nSizeof = sizeof(A1);

nSizeof = sizeof(A2);

nSizeof = sizeof(A3);

nSizeof = sizeof(A4);

nSizeof = sizeof(B);

nSizeof = sizeof(B1);

nSizeof = sizeof(C);

nSizeof = sizeof(C1);

nSizeof = sizeof(C2);

nSizeof = sizeof(C3);

nSizeof = sizeof(C4);

nSizeof = sizeof(C4);

}

}