C++类的存储及类对象内存结构

转载自：http://blog.csdn.net/fenxinzi557/article/details/51995911

本文分两部分，前半部分讲类的存储后半部分讲类的内存结构。
C++类的存储
c++中最重要的就是类，那么一个类的对象，它在内存中如何存储的？它占
内存中多少个字节？
首先确定类的构成：
1，数据成员：可以是内置类型，类类型。
2，函数成员：虚函数，非虚函数
1）数据成员
内置类型对齐原则
内置类型就是常用的：char,short,long,int,float,double.
这些内置类型在类的对象中对齐方式，字节为单位（在c 中结构体也是一样的）
char 1
short 2
long 4
int 4
float 4
fouble 8
类类型对齐原则（c 中就是结构体对齐原则）
取类中最长的数据成员作为对齐原则。例如，类中最长为 double,那么就是8 个字节。
2）函数成员
函数成员是不占用内存中类的对象的字节。为什么呢，你可以这样理解，c++中为了兼容c
也允许struct 作为类的声明。在c 中struct 是用来声明结构体类型的，只不过c 中的结构
体没有函数成员。
同样 c++中允许的函数成员，只不过是类给函数提供了一个作用域。
一个对象调用函数的时候，可以等价为普通函数的调用

下面举个例子说明类对象的字节数

eg.1:

class A
{
    char c;
    int i;
};
A a;

这对象a 的内存大小sizeof(a)=8(字节为单位）
解释下：
c 放在起始位置0，占1 个字节。
i 是int 要4 字节对齐，所以前面要空3 字节。它要从位置4 开始存储，占4，5，6，7 四
个位置。
最后类要按照他最长的数据成员对齐，就是i 也就是4 字节对齐.因为已经占用了8 个字节，
8 是对齐4 的，所以不用额外增加字节数了。最后sizeof(a)=8。
例子eg.2:

class B
{
doube d;
char c;
A a;//1 中的类类型A
};
B b;

这对象b 的内存大小sizeof(b)=24(字节为单位）
解释：
d 放在起始位置0 到7，占8 个字节。
c 是char 要1 字节对齐，所以放在位置8，占1 个字节。
b 是类类型，在1 中可以知道它是8 字节对齐的，所以前面要空7 个字节，它从位置16
开始存储，一直到23，占8 个字节。
最后类要按照他最长的数据成员对齐，就是d 也就是8 字节对齐，因为已经占用了24 个字
节，24 是对齐8 的，所以不用额外增加字节数了。最后sizeof(a)=24。
例子eg.3:

class c
{
char c;
int i1;
double d;
int i2;
};
C c;

你知道sizeof(c)=多少吗？ 答案：首先存储字符变量c，0位置存储，占1个字节；然后存储整型变量i1，4个字节对齐，因此从4~7位置存储，占4个字节；然后存储双精度变量d,从8~15位置存储，占8个字节；最后存储整型变量i2，从位置16~19存储占4个字节；最后对齐到最长的（8个字节），及补全20~23位置，整个占24个字节。
下面说下特殊的，就是 c 中没有的。
【1】类中有虚函数的时候
我们在一开始的时候，就说了成员函数中有虚函数。c++为了处理多态，所以引入虚函数，
在一个类对象存储空间中，第一个位置需要4 个字节来存储一个指针。这个指针是指向改
类的虚函数表的。也就是这个指针的值就是改类的虚函数表的地址。所以就比上面说的多了
4 个字节。
例如：

class D
{
public:
virtual void f(){};
double d;
}
D d; 

sizeof(d)=16;
【2】派生类内存大小
例如：

class E:D
{
int d0;
char c;
int d1;
};
E e; 

sizeof(e)=32;
解释：
基类中有虚函数，所以派生类对象一开始要 4 个字节存储指向虚函数表的指针。
然后继承 D 中的数据成员double d;
它要8 字节对齐，所以前面空4 个字节。
下面就开始存储 d0,c,d1.最后类对齐可计算得到32. 类对象内存结构
首先介绍一下C++中有继承关系的类对象内存的布局：
在C++中，如果类中有虚函数，那么它就会有一个虚函数表的指针__vfptr，在类对象最开始的内存数据中。之后是类中的成员变量的内存数据。
对于子类，最开始的内存数据记录着父类对象的拷贝（包括父类虚函数表指针和成员变量）。 之后是子类自己的成员变量数据。
对于子类的子类，也是同样的原理。但是无论继承了多少个子类，对象中始终只有一个虚函数表指针。

为了探讨C++类对象的内存布局，先来写几个类和函数
首先写一个基类：

class Base
{
public:
virtual void f() { cout << “Base::f” << endl; }
virtual void g() { cout << “Base::g” << endl; }
virtual void h() { cout << “Base::h” << endl; }
int base;
protected:
private:
}; 

然后，我们多种不同的继承情况来研究子类的内存对象结构。
（1） 无虚函数集继承 //子类1，无虚函数重载

class Child1 : public Base
{
public:
virtual void f1() { cout << “Child1::f1” << endl; }
virtual void g1() { cout << “Child1::g1” << endl; }
virtual void h1() { cout << “Child1::h1” << endl; }
int child1;
protected:
private:
}; 

这个子类Child1没有继承任何一个基类的虚函数，因此它的虚函数表如下图：