C++入门知识点总结

类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数（这是笼统的说，后面会细说）是不计算在内的。

示例如下：

(一)

class CBase
{
}; 

sizeof(CBase)=1；

为什么空的类什么都没有是 1 呢？

c++要求每个实例在内存中都有独一无二的地址。空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的 sizeof 为 1。

(二)

class CBase
{
	int a;
	char p;
}; 

sizeof(CBase)=8;

记得对齐的问题，这点和 struct 的对齐原则很像！int 占 4 字节，char 占一字节，补齐 3 字节。

(三)

class CBase
{
public:
	CBase(void);
	virtual ~CBase(void); 

private:
	int  a;
	char *p;
}; 

sizeof(CBase)=12

C++ 类中有虚函数的时候有一个指向虚函数的指针，在 32 位系统分配指针大小为 4 字节。无论多少个虚函数，只有这一个指针，4 字节。注意一般的函数是没有这个指针的，而且也不占类的内存。

(四)

class CChild : public CBase
{
public:
	CChild(void);
	~CChild(void); 

virtual void test();
	private:
	int b;
}; 

sizeof(CChild)=16；

可见子类的大小是本身成员变量的大小加上父类的大小。其中有一部分是虚拟函数表的原因，父类子类共享一个虚函数指针。

(五)

#include<iostream.h>

class a {};

class b{};

class c:public a
{
	virtual void fun()=0;
};

class d:public b,public c
{
};

int main()
{
cout<<"sizeof(a)"<<sizeof(a)<<endl;
cout<<"sizeof(b)"<<sizeof(b)<<endl;
cout<<"sizeof(c)"<<sizeof(c)<<endl;
cout<<"sizeof(d)"<<sizeof(d)<<endl;

return 0;
}

sizeof(a)=1
sizeof(b)=1
sizeof(c)=4
sizeof(d)=8

注意第三种情况和第四种情况。

(六)

#include<iostream>
using namespace std;

class A
{
	char a[3];
public:
	virtual void fun1(){};
};

class B : public virtual A
{
	char b[3];
public:
	virtual void fun2(){};
};

class C : public virtual B
{
	char c[3];
public:
	virtual void fun3(){};
};

int main()
{
	cout << sizeof(A) << endl; // 8
	cout << sizeof(B) << endl; // 8(A) + 12(B)
	cout << sizeof(C) << endl; // 8(A) + 12(B) + 12(C)
	return 0;
}

sizeof(A)=8
sizeof(B)=20
sizeof(c)=32

注意，虚继承的时候A B C三个类不仅不会共享虚基类指针，也不会共享虚表指针，要和普通继承区分开来。

具体分析如下：

 class A size(8):
      +---
 0    | {vfptr}
 4    | a
      | <alignment member> (size=1)
      +---

 class B size(20):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | b
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | {vfptr}
16    | a
      | <alignment member> (size=1)
      +---

 class C size(32):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | c
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | {vfptr}
16    | a
      | <alignment member> (size=1)
      +---
      +--- (virtual base B)
20    | {vfptr}
24    | {vbptr}
28    | b
      | <alignment member> (size=1)
      +---

总结

空的类是会占用内存空间的，而且大小是 1，原因是 C++ 要求每个实例在内存中都有独一无二的地址。

（一）类内部的成员变量：

• 普通的变量：是要占用内存的，但是要注意对齐原则（这点和 struct 类型很相似）。
• static 修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。

（二）类内部的成员函数：

• 普通函数：不占用内存。
• 虚函数：有一个指向虚函数的指针，要占用 4 个字节，用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。

说明：此博文转载之http://blog.sina.com.cn/s/blog_69c189bf0100mkeu.html