决定c 中对象的大小的因素：
| 1.所有非静态数据成员的大小 |
| 2.数据成员的顺序 |
| 3.字节对齐或字节填充 |
| 4.其直接基类的大小虚函数的存在 |
| 5. 正在使用的编译器 |
| 6.继承模式（虚拟继承） |
一、使用sizeof计算类对象所占空间大小
需要注意，对类做sizeof运算时，并不是简单地把各个成员所占的内存数量相加。需要注意成员顺序不同，可能需要字节补齐。
编程实例：
#include
using namespace std;
class a
{
public:
int i; //int占用4个字节
};
class b
{
public:
char ch; //char占用1个字节
};
class c
{
public:
int i;
short j;//short占用2个字节
};
class d //d共占用8个字节
{
public:
int i; //int占用4个字节
short j; //short和char共占用3个字节，由于这里最宽的
char ch; //基本类型是int的4个字节，再填充一个字节凑成4的倍数
};
class e //e共占用8个字节
{
public:
int i;
int ii; //两个int共占用8个字节
short j; //1个short 2个char = 4个字节，刚好是最宽
char ch; //基本类型int的大小的整数倍，不需要再填充字节
char chr;
};
int main()
{
cout << "sizeof(a) = " << sizeof(a) << endl; //4
cout << "sizeof(b) = " << sizeof(b) << endl; //1
cout << "sizeof(c) = " << sizeof(c) << endl; //8
cout << "sizeof(d) = " << sizeof(d) << endl; //8
cout << "sizeof(e) = " << sizeof(e) << endl; //12
getchar();
return 0;
} 小结：
| 1.类中的数据成员顺序不同，类所占的内存大小可能不同； |
| 2.注意需要 字节对齐或字节填充 的情况； |
| 3.派生类的内存大小需要加上基类的内存大小。 |
拓展知识：关于字节对其你和字节填充
编程实例：
class c {
char c;
int int1;
int int2;
int i;
long l;
short s;
};分析:
这个类的大小是24字节。尽管char c只消耗1个字节，但将为它分配4个字节，剩下的3个字节将被浪费（留空）。这是因为下一个成员是int，它占用4个字节。如果我们不进入下一个（4）字节来存储这个整数成员，那么这个整数的内存访问/修改周期将是2个读周期。所以编译器会为我们做这个补位。
图解：
二、使用sizeof计算含有虚函数的类对象的空间大小
虚函数的存在将在类中添加4个字节的虚拟表指针，这将被添加到类的大小。 同样，在这种情况下，如果类的基类已经直接或通过其基类具有虚函数，那么这个额外的虚函数将不会添加任何类的大小。 虚拟表指针在类层次结构中是通用的。
编程实例：
#include
using namespace std;
class base //base占用的内存大小为4，即1个int
{
public:
base(int x) :a(x)
{
}
void print() //函数不占用内存
{
cout << "base" << endl;
}
private:
int a;
};
class derived :public base //derived的内存大小=base的大小 derived中的一个int,
{ //即4 4 = 8
public:
derived(int x) :base(x - 1), b(x)
{
}
void print()
{
cout << "derived" << endl;
}
private:
int b;
};
class a //a共占用8个字节
{
public:
a(int x) :a(x)
{
}
virtual void print() //虚函数产生一个隐含的虚表指针成员，占4个字节
{
cout << "a" << endl;
}
private:
int a; //占4个字节
};
class b :public a //b所占内存 = a所占内存 4
{
public:
b(int x) :a(x - 1), b(x)
{
}
virtual void print()
{
cout << "b" << endl;
}
private:
int b; //占4个字节
};
int main()
{
base obj1(1);
cout << "size of base obj is " << sizeof(obj1) << endl; //4
derived obj2(2);
cout << "size of derived obj is " << sizeof(obj2) << endl; //8
a a(1);
cout << "size of a obj is " << sizeof(a) << endl; //8
b b(2);
cout << "size of b obj is " << sizeof(b) << endl; //12
getchar();
return 0;
} 小结：
| 1. 普通函数不占用内存； |
| 2.只要有虚函数就会占用一个指针大小的内存，原因是系统多用一个这镇维护这个类的虚函数表。 |
三、使用sizeof计算虚拟继承的类对象的空间大小
要点：在c 中，有时由于某些原因，我们不得不使用虚拟继承。当我们使用虚拟继承时，在该类中，虚拟基类指针将会有4个字节的开销。
编程实例：
#include
using namespace std;
class a //空类的大小不为零，一般来说它是1个字节,
{ //确保两个不同的对象具有不同的地址是非零的
};
class b //1个字节
{
};
class c :public a, public b { //1个字节
};
class d :virtual public a { //虚函数的存在将在类中添加4个字节
//的virtual table pointer
};
class e :virtual public a, virtual public b { //虚继承a有4个字节
//虚继承b有4个字节
};
class f
{
public:
int a; //占4个字节
static int b; //静态成员的空间不在类的实例中，
//而是像全局变量一样在静态存储区
};
int f::b = 10; //在类外初始化静态成员
int main()
{
cout << "sizeof(a) = " << sizeof(a) << endl; //1
cout << "sizeof(b) = " << sizeof(b) << endl; //1
cout << "sizeof(c) = " << sizeof(c) << endl; //1
cout << "sizeof(d) = " << sizeof(d) << endl; //4
cout << "sizeof(e) = " << sizeof(e) << endl; //8
cout << "sizeof(f) = " << sizeof(f) << endl; //4
getchar();
return 0;
} 知识扩展：为什么c 中空类的大小不为零？
例如：
#include
using namespace std;
class empty {};
int main()
{
cout << sizeof(empty);
return 0;
} 输出结果：
| 1 |
分析：
空类的大小不为零。一般是1个字节。确保两个不同的对象具有不同的地址是非零的。
例如：
#include
using namespace std;
class empty { };
int main()
{
empty a, b;
if (&a == &b)
cout << "a 和 b的地址相同 " << endl;
else
cout << "a 和 b的地址不同 " << endl;
return 0;
} 输出结果：
| a 和 b的地址不同 |
还有另外一种情况，你可能会感到奇怪：
#include
using namespace std;
class empty { };
class derived: empty { int a; };
int main()
{
cout << sizeof(derived);
return 0;
} 输出：
| 4 |
为什么是4，而不是5？
原因是c 有一条规则表明空基类不需要用单独的字节表示。因此编译器可以在空基类的情况下自由优化。
<本文完>
参考资料：
1）https://www.geeksforgeeks.org
2）https://www.cprogramming.com
3）《c和c 程序员面试秘笈》