C++ sizeof() Class / C++ Class sizeof()

// test1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "iostream"

using namespace std;

class A
{};

class A1: public A
{};

class B
{
	bool a;
	int b;
public:
	void print()
	{
		cout<<"print"<<endl;
	}
};

class B1: public B
{
	bool c;
	int d;
public:
	void say()
	{
		cout<<"say"<<endl;
	}
};

class C
{
	
public:
	virtual ~C()
	{}
};

class C1:public C
{
public:
	~C1()
	{}
};

class D
{
	static int a;
	bool c;
	short b;
public:
	virtual ~D(){};
};

class D1:public D
{
public:
	~D1(){}
};

class E
{
	int a;
public:
	void test(){}
};

class E1:public E
{
	int b;
public:
	void test2(){} 
};

class F
{
public:
	virtual ~F(){}
	virtual void test(){}
	virtual void print(){}
	virtual void say(){}
	void hello(){}
};

class F1: public F
{
public:
	void hello(){}
	~F1(){}
	void test(){}
	void print(){}
	void say(){}
};

class G
{};

class G1: public virtual G
{};

class H
{
	char a;
public:
	virtual ~H(){}
	virtual void test(){}
};

class H1:public virtual H
{
	char b;
public:
	virtual ~H1(){}
	void test(){}
};

class I
{
	char a;
public:
	virtual ~I(){}
	virtual void test(){}
};

class I1:public I
{
	char a;
public:
	virtual ~I1(){}
	virtual void test(){}
};

int _tmain(int argc, _TCHAR* argv[])
{
	// 空的基类和空的派生类，大小都为1
	// 空的基类
	cout<<"empty base class:"<<sizeof(A)<<endl;
	// 空的派生类
	cout<<"empty derived class:"<<sizeof(A1)<<endl;


	// 基类中需要进行内存对齐
	// 函数不占用sizeof()空间
	// 因为sizeof()只统计在栈中的大小，所以可能函数没有在栈中，就不会统计了
	// 还有类的静态变量
	cout<<"align base class:"<<sizeof(B)<<endl;
	// 派生类包含基类的基本变量，但是函数同样不占用内存，也存在内存对齐问题
	cout<<"align derived class:"<<sizeof(B1)<<endl;


	// 类包含虚析构函数，包含虚函数的类会包含一个指向虚函数表的指针
	cout<<"align base class (虚析构函数):"<<sizeof(C)<<endl;
	// 派生类也包含指向虚函数表的指针
	// 这个时候，派生类只包含一个虚函数表的指针，基类的虚函数表的指针没有继承
	// 而是直接使用派生的虚函数表的指针
	cout<<"align derived class (虚析构函数):"<<sizeof(C1)<<endl;


	// sizeof()只统计在栈中的大小，所以类的静态成员变量也不会统计
	// 这个时候变量对齐到2B,变量两个各占2B，虚指针占4B 
	cout<<"align base class (虚析构函数, 含有静态变量):"<<sizeof(D)<<endl;
	// 派生类包含一个虚指针，而且派生类中包含的基类不再包含虚指针，
	// 在继承层次中，派生类中只包含一个虚指针，不会和基类重复包含虚指针
	cout<<"align derived class (虚析构函数, 含有静态变量):"<<sizeof(D1)<<endl;

	// 类中的函数在sizeof()中不会统计函数占用空间 
	cout<<"align base class (含有函数):"<<sizeof(E)<<endl;
	// 派生类继承基类，但是函数仍然不占用空间
	cout<<"align derived class (含有函数):"<<sizeof(E1)<<endl;

	// 虚函数测试
	// 不管类中包含多少个虚函数，使用sizeof()都只统计一个虚函数表指针，
	// 普通函数不占用空间，也不存在指针
	cout<<"align base class (含有虚函数&普通函数):"<<sizeof(F)<<endl;
	// 派生类中，普通函数不占空间，派生类只包含一个虚指针，基类的虚指针被覆盖
	cout<<"align derived class (含有虚函数&普通函数):"<<sizeof(F1)<<endl;

	// 测试虚继承
	// 空基类占用字节1B
	cout<<"align base class (虚继承):"<<sizeof(G)<<endl;
	// 派生类虚继承基类，则会包含一个虚指针指向虚函数表
	// 派生类只包含一个虚指针，大小为4B
	cout<<"align derived class (虚继承):"<<sizeof(G1)<<endl;

	// 虚函数继承：至于虚继承和虚函数继承有神马区别，暂时还没弄清。。。
	cout<<"align base class(虚函数继承):"<<sizeof(H)<<endl;
	// sizeof(H1) = 20B
	// 首先，基类的所有的大小都包含进来，包含基类的变量和基类的虚指针
	// 注意：基类的虚指针只有是虚函数继承的时候才会被包含进来，上面的普通的继承的时候
	// ，只有派生类包含一个虚函数指针，基类是不包含虚函数指针的
	// 然后，派生类包含一个char b, 对齐后占4B
	// 派生类还包含一个指向基类虚函数表的虚指针，占4B
	// 派生类本身还包含一个指向自己虚函数表的指针，占4B，共20B
	cout<<"align derived class(虚函数继承):"<<sizeof(H1)<<endl;


	// 普通的继承
	// 基类包含一个虚函数指针
	cout<<"align base class(普通继承，包含虚函数指针):"<<sizeof(I)<<endl;
	// 普通的继承不会像上面那样，派生类包含基类的所有的内容，（包括基类的虚函数指针）
	// 普通的继承中，派生类的虚函数指针会覆盖基类的虚函数指针，只有一个虚函数指针
	cout<<"align derived class(普通继承，包含虚函数指针):"<<sizeof(I1)<<endl;

	system("pause");
	return 0;
}