空类

#include <iostream>
using namespace std;

class Base
{
    void f(){};
};

int main()
{
    cout << sizeof(Base) << endl; //1
    return 0;
}

虚继承空类的类大小

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

class Base
{
    void f(){};
};

class Derived2 : public virtual Base
{
    void d2();
};


int main()
{
    cout << sizeof(Derived2) << endl; //8 64位下 有一个指向虚基类的指针
    return 0;
}

虚函数

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

class Base
{
    virtual void f(){};
};

class Derived1 : public Base
{
    void d1();
};

class Derived2 : public Base
{
    virtual void d2();
};


int main()
{
    cout << sizeof(Base) << endl; //8 64位下 有一个指向虚函数表的指针
    cout << sizeof(Derived1) << endl; //8 64位下 有一个指向虚函数表的指针
    cout << sizeof(Derived2) << endl; //8 64位下 有一个指向虚函数表的指针
    return 0;
}

虚函数 + 虚继承

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

class Base
{
    virtual void f(){};
};

class Derived1 : public Base
{
    void f1();
};

class Derived2 : public Base
{
    virtual void f2();
};

class Derived3 : public virtual Base
{
    virtual void f3();
};

int main()
{
    cout << sizeof(Base) << endl; //8 64位下 有一个指向虚函数表的指针
    cout << sizeof(Derived1) << endl; //8 64位下 有一个指向虚函数表的指针
    cout << sizeof(Derived2) << endl; //8 64位下 有一个指向虚函数表的指针
    //每个虚继承的子类都有一个虚基类指针和虚基类表
    //虚继承 并且有虚函数 跟编译器有关系
    //vs是24（64位） 基类的虚函数表指针 自己的虚函数表指针 指向虚基类的指针
    //gcc是8（64位） ？？？有点疑惑
    cout << sizeof(Derived3) << endl; 
    return 0;
}

成员变量

有成员变量的类

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

class Base
{
public:
    int a;
    int b;
    virtual void f(){};
};

class Derived1 : public Base
{
    void f1();
};

class Derived2 : public Base
{
    virtual void f2();
};



int main()
{
    //4 + 4 + 8
    cout << sizeof(Base) << endl; 
    cout << sizeof(Derived1) << endl; 
    cout << sizeof(Derived2) << endl; 


    return 0;
}

静态成员变量

静态成员变量不属于类，计算类大小的时候不用考虑

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

class Base
{
public:
    int a;
    int b;
    static int x;
    virtual void f(){};
};

class Derived1 : public Base
{
    void f1();
};

class Derived2 : public Base
{
    virtual void f2();
};



int main()
{
    //4 + 4 + 8
    cout << sizeof(Base) << endl;
    cout << sizeof(Derived1) << endl;
    cout << sizeof(Derived2) << endl;


    return 0;
}

多重继承

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

class Base
{
    virtual void f() {};
};

class Derived1
{
    virtual void f1() {};
};

class Derived2 : public Base, Derived1
{
    virtual void f2() {};
};


int main()
{
    cout << sizeof(Base) << endl; //8 64位下 有一个指向虚函数表的指针
    cout << sizeof(Derived1) << endl; //8 64位下 有一个指向虚函数表的指针
    cout << sizeof(Derived2) << endl; //16 64位下 多个虚函数表指针 ??? 
    return 0;
}