C++中一些类和数据结构的大小的总结

针对class，虚函数等情况写了一些代码测试。

#include <stdio.h>

class A {
};

class B {
public:
        void f();
        void g();
};

class C {
public:
        void f();
        void g();
private:
        int a;
};

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

class E: public D {
private:
        int a;
};

class F{
private:
        int a;
};

class G {
public:
        virtual void f();
        virtual void g();
        virtual void h();
};

class H: public G {
private:
        int a;
};

class I: public G {
};

class J: public I {
};

class K {
public:
        virtual void f();
        virtual void g();
private:
        int a;
};

class L {
public:
        virtual void f();
        virtual void g();
private:
        int a;
        int b;
};

class M {
public:
        virtual void f();
        virtual void g();
private:
        int a;
        int b;
        int c;
};

int main(int argc, char ** argv) {
        printf( "A: %d, B: %d, C: %d, D: %d, E :%d, F: %d, G: %d, "
                "H: %d, I: %d, J: %d, K: %d, L: %d, M: %d, "
                "int size: %d, long size: %d, double size: %d.\n",
                sizeof(A), sizeof(B), sizeof(C),
                sizeof(D), sizeof(E), sizeof(F),
                sizeof(G), sizeof(H), sizeof(I),
                sizeof(J), sizeof(K), sizeof(L),
                sizeof(M),
                sizeof(int), sizeof(long), sizeof(double));
}

运行结果：

[sizeTest]$ g++ -o sizeTest sizeTest.cpp 
[sizeTest]$ ./sizeTest 
A: 1, B: 1, C: 4, D: 8, E :16, F: 4, G: 8, H: 16, I: 8, J: 8, K: 16, L: 16, M: 24, int size: 4, long size: 8, double size: 8.

总结如下:

A: 空类占用1字节

B: 成员函数不占空间，所以仍然1字节

C: private变量仍然占用空间，int为4

D: 虚函数（表）占用1个long的大小，为8字节

E：变量排在虚函数表前面，所以要对齐，一共16字节

F: 没有成员函数，只有成员变量，也是int的4字节

G：多个虚函数不增加空间大小

H：与E一样的效果

I: 虚函数继承不增加大小

J: 多次继承也不增加

K,L,M：检验对齐的效果

long和double的size都为8，int为4.