关于类对象大小的 sizeof 计算问题

之前看了很多关于类对象大小问题的计算，今天闲着没事就来整理整理，写写自己的看法。

首先，来看看一个只有构造函数和析构函数的空类：

#include <iostream>
using namespace std;
class Base
{
public:
    Base();
    ~Base();
};
int main(int argc, char *argv[])
{
    cout << sizeof(Base) << endl;
}

输出结果为：1

      因为一个空类也要实例化，所谓类的实例化就是在内存中分配一块地址，每个实例在内存中都有独一无二的地址。同样空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。 而析构函数，跟构造函数这些成员函数，是跟sizeof无关的，也不难理解因为我们的sizeof是针对实例，而普通成员函数，是针对类体的，一个类的成员函数，多个实例也共用相同的函数指针，所以自然不能归为实例的大小。

     如果给这个类添加成员变量，最后输出的大小就是这些成员变量的大小之和（这里涉及到一个成员对齐问题，不再叙述了）。

接下来再来看一个有继承的例子：

#include <iostream>
using namespace std;
class Base
{
public:
    Base();
    ~Base();
    void set_num(int num)    //普通成员函数
    {
        a=num;
    }
private:
    int  a;                  //占4字节
    char *p;                 //4字节指针
};
class Derive:public Base
{
public:
    Derive():Base(){};
    ~Derive(){};
private:
    static int st;         //非实例独占
        int  d;                //占4字节
};
int main(int argc, char *argv[])
{
    cout<<sizeof(Base)<<endl;
    cout<<sizeof(Derive)<<endl;
    return 0;
}

输出结果为：8   12

结果很显然， Base 类按4字节对齐，所以是8个字节，Derive 类中不但继承了Base 类的两个成员变量，还多了两个成员变量，但大小却只有12字节，可以得出：静态变量在计算时是不做考虑的。

上面的例子中都没有涉及到虚函数，下面看个有虚函数的例子：

#include <iostream>
using namespace std;
class Base
{
public:
    Base() {}
    virtual ~Base() {}
};
int main(int argc, char *argv[])
{
    cout << sizeof(Base) << endl;
    return 0;
}

输出结果为：4

      和第一个程序相比，这个类中，析构函数变成了虚函数，类的大小也变成了4字节，这是因为有了虚函数，编译器就会为类创建一个虚函数表(vtable)，并创建一个指针(vptr)指向这个虚函数表。所以类大小变为4字节。如果在 Base 类中再添加新的虚函数，该类的大小还是不会变，因为指向虚函数的指针是放在虚函数表中的，指向虚函数表的指针不会变。

如果在这个类中添加数据成员，就会在4字节的基础上对象大小。

下面再来看看虚函数的继承问题：

#include <iostream>
using namespace std;
class Base
{
public:
    Base();
    virtual ~Base();
    void set_num(int num)    //普通成员函数
    {
        a=num;
    }
private:
    int  a;                  //占4字节
    char *p;                 //4字节指针
};
class Derive:public Base
{
public:
    Derive():Base(){};
    ~Derive(){};
    virtual void foo() { }
private:
    static int st;         //非实例独占
        int  d;                //占4字节
};
int main(int argc, char *argv[])
{
    cout<<sizeof(Base)<<endl;
    cout<<sizeof(Derive)<<endl;
    return 0;
}

输出结果为：12    16

      Base类的大小为12字节很显然，Derive 类中，虽然有一个虚函数 foo ，但是因为它是从Base 类继承的，所以也继承了其虚函数表，并没有创新新的虚函数表，只是在继承下来的表中添加了一项，所以大小为16字节。

再来看看一个虚继承的例子：

#include <iostream>
using namespace std;
class Base
{
public:
    Base();
    virtual ~Base();
    void set_num(int num)    //普通成员函数
    {
        a=num;
    }
private:
    int  a;                  //占4字节
    char *p;                 //4字节指针
};
class Derive:virtual public Base
{
public:
    Derive():Base(){};
    ~Derive(){};
    virtual void foo() { }
private:
    static int st;         //非实例独占
        int  d;                //占4字节
};
int main(int argc, char *argv[])
{
    cout<<sizeof(Base)<<endl;
    cout<<sizeof(Derive)<<endl;
    return 0;
}

输出结果为：12    20

      这里由于虚继承而引入了一个间接的指针(vbc)，该指针是指向虚函数表的一个slot，表中存放着该slot中存放虚基类子对象的偏移量的负值。所以大小比之前多了4字节。就算同时虚继承自两个类，也只会有一个这样的间接指针，也就是大小也只多4字节。

说到这里，关于类对象大小问题的计算应该差不多了。