C++ 类对象内存模型分析

编译环境：Windows10 + VS2015

1、空类占用的内存空间

类占内存空间是只类实例化后占用内存空间的大小，类本身是不会占内存空间的。用sizeof计算类的大小时，实际上是计算该类实例化后对象的大小。空类占用1字节原因：C++要求每个实例在内存中都有一个唯一地址，为了达到这个目的，编译器会给空类隐含添加1字节，保证空类实例化后在内存中得到的地址是独一无二的。所以如下代码中sizeof(A)（实际上是用类A的默认构造函数构造A的临时对象，然后求这个临时对象的大小），sizeof(obj)大小都是1字节。

class A 
{
};

int main()
{    
    int nLen = sizeof(A);
    std::cout<<nLen<<std::endl;      //输出为1
    A obj;
    nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为1
    return 0;
}

我们可以在快速监视对话框中找到obj的内存地址。

在内存窗口中找到该内存地址0x012ff8c7，说明内存中确实给空类的实例化对象分配了1字节内存空间。

2、类成员函数不占内存空间

类的普通成员函数不占内存空间。下列代码中A类添加了3个成员函数，此时类A 实例化对象obj大小仍然为1字节。原因是：成员函数还是以一般函数一样的存在，obj.fun1()是通过fun1(obj.this)来调用的。所谓成员函数名义上是类中的，其实成员函数的大小不再类对象里面，同一个类的多个对象共享函数代码。而我们访问类的成员函数是通过类的指针实现，而这个指针指向的是一个table，table里面记录了各个成员函数的地址（不同编译器可能有不同的实现）。所以，访问成员函数是间接获得地址的，这样也增加了一定的时间开销，这也是为什么提倡不一些简短的、调用频率高的函数声明为inline形式（内联函数）。

同理，类中构造函数和析构函数不占内存空间。

class A 
{
public:
    void fun1() {}
    int fun2() { return 0; }
    long long fun3() { return 0l; }
};

int main()
{    
    A obj;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为1
    return 0;
}

3、虚函数占用内存空间

C++类有虚函数的时候，会产生一个指向虚函数表的指针（vptr），在32位系统分配指针大小为4字节。而类中只要有虚函数，这个类就会产生一个指向虚函数的指针，有两个虚函数则产生两个指向虚函数的指针。而类中的指向虚函数的指针（一个或多个）要有一个地方存放，这些指针放在一个表格里（称为虚函数表），这个虚函数表保存在可执行文件中，在程序执行时载入到内存中。不管类中多多少个虚函数，其指向虚函数表的指针只有一个，占4个字节。注意一般从成员函数没有这个指针，因此不占类的内存空间。

1）有虚函数类产生一个指向虚函数表指针，占4字节。

class A 
{
public:
    virtual  void fun1() {}
    virtual  void fun2() {}
};

int main()
{    
    A obj;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为4    
    return 0;
}

内存分布如下图所示，类的地址0x006ffe88存放的是指向类虚函数表的指针地址0x00886b34。

2）父类与子类共享虚函数表指针，且子类的大小是其本身成员变量大小加上父类大小（在c++标准中，如果基类没有成员时，基类不应占空间，所以标准允许派生类的第一个成员与基类共享地址，此时基类不占据任何实际空间）。

class A 
{
public:
    virtual  void fun1() {}
    virtual  void fun2() {}
};
class B :public A {
public:
    virtual  void fun3() {}
    virtual  void fun4() {}
};
int main()
{    
    B obj;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为4    
    return 0;
}

内存分布如下：

通过VS2015可以查看到B对应的虚函数表。命令如下：

cl /d1 reportSingleClassLayoutB D:\ConsoleApplication1\ConsoleApplication1\ConsoleApplication1.cpp

显示如下：

3）虚函数表指针与类的成员变量一样参与类的字节对齐。所以如下代码中sizeof(obj)占8字节。

class A 
{
public:
    virtual  void fun1() {}
    virtual  void fun2() {}
    
};
class B
{
private:
    char c;
};
class C:public A,public B
{};
int main()
{    
    C obj;
    
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为8    
    return 0;
}

4、成员变量占内存空间

用例一

在A类中加入字符型变量a，可以看到类A对象obj的大小是1字节。

class A 
{
public:
    void fun1() {}
    int fun2() { return 0; }
    long long fun3() { return 0l; }
    char a;
};

int main()
{    
    A obj;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为1
    obj.a = 'b';
    return 0;
}

在快速监视对话框中找到obj的内存地址为0x00aff93f。此时该内存地址并未存储有效值。

执行obj.a='b'语句后，原来obj地址0x00aff93f存储上了十六进制数62，而十六进制62刚刚是字符b的ASCII码值。刚好1字节大小，跟sizeof(obj)输出吻合，同时也说明成员变量占用类对象空间。

用例二

在A类中变量a修改为整型型，可以看到类A对象obj的大小是4字节（刚好为sizeof(int)大小）。

class A 
{
public:
    void fun1() {}
    int fun2() { return 0; }
    long long fun3() { return 0l; }
    int a;
};

int main()
{    
    A obj;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为4
    obj.a = 'b';
    return 0;
}

开启调试，在内存中可以看到obj地址为0x009cf758。此时地址0x009cf758并未存储值。

执行obj.a = 'b'赋值语句后，在0x009cf758地址处存储了十六进制数62，刚好是字符b的ASCII码值。

用例三

在A类中加入字符变量a，整型b。可以看到类A对象obj的大小是8字节（为什么为8个字节呢？这涉及到类的字节对齐问题）。

class A 
{
public:
    void fun1() {}
    int fun2() { return 0; }
    long long fun3() { return 0l; }
    char a;
    int b;
    
};

int main()
{    
    A obj;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为8
    obj.a = 'a';
    obj.b = 'b';
    return 0;
}

开启调试，在内存中可以看到obj占用的内存地址范围为0x001cfae8~0x001cfaef共8个字节内存空间。

执行obj.a = 'a'；obj.b= 'b'；赋值语句后在地址0x001cfae8处存储了十六进制数61，地址0x001cfaec出存储了十六进制数62。刚好为a,b的ASCII码值。

5、static修饰的静态成员变量不占内存空间

static修饰的静态成员变量不占内存空间，原因是编译器将其放在全局变量区。

class A 
{
public:
    virtual  void fun1() {}
    virtual  void fun2() {}
    static int a;
};
int A::a = 62; //须在类外初始化
int main()
{    
    A obj;
    A::a = 63;
    int nLen = sizeof(obj);
    std::cout << nLen << std::endl; //输出为4    
    return 0;
}

内存布局如下图：