总结

• 原则1：空类的大小为1字节
• 原则2：一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
• 原则3：对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针vptr的大小。
• 原则4：普通继承和派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
• 原则5：虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！
• 原则6：虚继承，继承基类的vptr

原则1：空类的大小为1字节

#include<iostream>
using namespace std;
class A{};
int main()
{
    cout<<sizeof(A)<<endl;
    return 0;
}

//输出
1

原则2：一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。

#include<iostream>
using namespace std;
class A
{
    public:
        char b;
        virtual void fun() {};
        static int c;
        static int d;
        static int f;
};

int main()
{
    /**
     * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
     */
    cout<<sizeof(A)<<endl; 
    return 0;
}

//输出
16

上述例子中，只用虚指针占了八个字节（虚函数不占存储空间），非静态数据成员char b占了1个字节，又由于字节对齐，所以一共占了16个字节！

原则3：对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针vptr的大小。

#include<iostream>
using namespace std;
class A{
    virtual void fun();
    virtual void fun1();
    virtual void fun2();
    virtual void fun3();
};
int main()
{
    cout<<sizeof(A)<<endl; // 8
    return 0;
}

//输出
8

原则4与5：

/**
 * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
 * 注意：类的数据成员按其声明顺序加入内存，与访问权限无关，只看声明顺序。
 * 2.虚单继承，派生类继承基类vptr
 */

#include<iostream>

using namespace std;

class A
{
public:
    char a;
    int b;
};

class B:A
{
public:
    short a;
    long b;
};

class C
{
    A a;
    char c;
};

class A1
{
    virtual void fun(){}
};

class C1:public A
{
};

int main()
{
    cout<<"char:"<<sizeof(char)<<endl;//1
    cout<<"int:"<<sizeof(int)<<endl;//4
    cout<<"short:"<<sizeof(short)<<endl;//2
    cout<<"long:"<<sizeof(long)<<endl;//4

    cout<<"A:"<<sizeof(A)<<endl; // 8=4+4
    cout<<"B:"<<sizeof(B)<<endl; // 16=8+4+4
    cout<<"C:"<<sizeof(C)<<endl; // 12=8+4
    cout<<"A1:"<<sizeof(A1)<<endl;// 8
    cout<<"C1:"<<sizeof(C1)<<endl; // 8

    return 0;
}

//输出
char:1
int:4
short:2
long:4
A:8
B:16
C:12
A1:8
C1:8

原则6：虚继承，继承基类的vptr

#include<iostream>
using namespace std;
class A
{
    virtual void fun() {}
};
class B
{
    virtual void fun2() {}
};
class C : virtual public  A, virtual public B
{
public:
    virtual void fun3() {}
};

int main()
{
    /**
     * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
     */
    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);

    return 0;
}

//输出
8 8 16

注意最后一个类C的输出，是16，fun3没有作用，也就是说：虚函数只继承基类的vptr！