C++类对象所占内存空间大小分析

前言

        类占内存空间是只类实例化后占用内存空间的大小，类本身是不会占内存空间的。用 sizeof 计算类的大小时，实际上是计算该类实例化后对象的大小。空类占用1字节原因：C++要求每个实例在内存中都有一个唯一地址，为了达到这个目的，编译器会给空类隐含添加1字节，保证空类实例化后在内存中得到的地址是独一无二的。

        在C++里空类占的存储空间是0吗？类的成员函数占存储空间吗？类的虚成员函数占存储空间吗？如果对这几个问题的回答不是很确定的话，此篇内容可供参考。

1.空类占用1个字节的存储空间

#include <iostream>
using namespace std;class A {};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;// 定义两个对象a1,a2A a1;A a2;cout << "由类A实例化后的对象a1的地址：" << &a1 << endl;cout << "由类A实例化后的对象a2的地址：" << &a2 << endl;system("pause");return 0;
}

输出结果： （ 每次运行程序时系统为对象 a1、a2 分配的地址不唯一）

原因：类中没有任何成员变量，占用的存储大小本该为0，但是如果是0，类实例化出的对象就不会在内存上占用空间，没有地址，也就无法区分这些对象。为了解决这个问题，编译器会给空类隐含加一个字节，保证用此类定义的对象都有一个独一无二的地址。 

2.类中的普通变量占用存储空间

#include <iostream>
using namespace std;class A {int a; // int类型变量achar p; // char类型变量p
};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;system("pause");return 0;
}

输出结果： 

 

        记得对齐的问题，这点和 struct 的对齐原则很像！int 占 4 字节，char 占 1 字节，补齐 3 字节。因此类 A 占8字节！

3.类的成员函数（非虚函数）不占用存储空间

在1的基础上增加类的成员函数做测试：

#include <iostream>
using namespace std;class A {
public:A(){} // 构造函数~A(){} // 析构函数int func1(){ return 0;} // 普通成员函数int func2(){ return 0;} // 普通成员函数
};int main(){cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;return 0;
}

输出结果： 

原因：成员函数（包括构造和析构函数）编译后存放在代码区，不占用类的存储空间。

4.类的静态成员变量不占用存储空间

在3的基础上定义一个静态成员变量做测试：

#include <iostream>
using namespace std;class A {
public:A() {} // 构造函数~A(){} // 析构函数int func1() { return 0; } // 普通成员函数int func2() { return 0; } // 普通成员函数private:static int num; // 类的静态成员变量
};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;system("pause");return 0;
}

输出结果： 

原因：类里的静态成员变量在全局数据区中分配空间，不占用类的存储空间，全局只有一份，不会随着类的实例化存储在每个对象里。 

5.类中的虚函数占用存储空间，但所占的空间不会随着虚函数的个数增长

在4的基础上定义3个虚成员函数做测试：

#include <iostream>
using namespace std;class A {
public:A() {} // 构造函数~A(){} // 析构函数int func1() { return 0; } // 普通成员函数int func2() { return 0; } // 普通成员函数// 3个虚函数virtual int func3() { return 0; }virtual int func4() { return 0; }virtual int func5() { return 0; }virtual int func6() { return 0; }
private:static int num; // 类的静态成员变量
};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;system("pause");return 0;
}

输出结果：

(1) x86<32位> 情况下：

(2)x64<64位> 情况下：

原因：C++ 类中有虚函数的时候有一个指向虚函数的指针，在 32 位系统分配指针大小为 4 字节，而在 64 位系统分配指针大小为 8 字节。无论多少个虚函数，只有这一个指针，4 字节（32位系统）或者8字节（64位系统）。注意一般的函数是没有这个指针的，而且也不占类的内存。

6.继承 — 子类所占空间

#include<iostream>
class CBase // 基类
{
public:CBase(void); // 构造函数不占空间virtual ~CBase(void); // 虚析构函数占空间，所占空间根据系统位数而定private:int  a; // 普通变量占空间（4字节）char* p; // 指针类型变量占空间，根据系统位数而定
};class CChild : public CBase // 子类CChild继承Cbase
{
public:CChild(void); // 不占空间~CChild(void); // 不占空间virtual void test();// 父类子类共享一个虚函数指针private:int b;
};int main() {char* str;std::cout << sizeof(str) << std::endl;std::cout << sizeof(CBase) << std::endl;std::cout << sizeof(CChild) << std::endl;
}/*
32位系统下：
4 // 指针类型变量占4字节
12 // 虚析构函数指针占4字节+int a变量占4个字节+char* p占4个字节
16 // int类型变量b占4个字节+基类所占的12个字节// virtual void test();此时不占空间，原因是：父类子类共享一个虚函数指针
*//*
64位系统下：
8 // 指针类型变量占8字节
24 // 虚析构函数指针占8字节+(int a变量占4个字节+对齐另需4字节)+(char* p占4个字节+对齐另需4字节)
32 // (int类型变量b占4个字节+对齐另需4个字节)+基类所占的24个字节
*/

        可见子类的大小是本身成员变量的大小加上父类的大小。其中有一部分是虚函数表的原因，父类子类共享一个虚函数指针。

7.空类与多重继承的空类占用内存空间

#include <iostream>using namespace std;class A {};class A2 {};class B : public A {};class C : public A, public A2 {};class D : public virtual B {}; // 虚继承int main()
{cout << sizeof(A) << endl;cout << sizeof(B) << endl;cout << sizeof(C) << endl;cout << sizeof(D) << endl;return 0;}// 32位系统输出：
/*
1
1
1
4
*/// 64位系统输出：
/*
1
1
1
8
*/

        空类所占内存空间为1；单一继承或多重继承空类的空类所占空间还是1；但虚继承涉及虚指针，指针大小为4（32位系统），故虚继承后空类所占空间为4（32位系统）。

 8.单一继承或多重继承时类占用内存空间

#include <iostream>using namespace std;class A {};class A1 {};class B : public A {int b;
};class C : public A, public A1 {int c;
};int main()
{cout << sizeof(A) << endl;cout << sizeof(B) << endl;cout << sizeof(C) << endl;return 0;}// 32位系统输出：
/*
1
4
8
*/// 64位系统输出：
/*
1
4
8
*/

9.共有继承

#include <iostream>class A {
};class A1 : public A {
};class B : public A{virtual void fun() = 0; // 定义虚函数
};// 共有继承，共用虚函数指针，没有虚基指针
class C : public B{
};class D : public A, public B{
};int main()
{std::cout << "sizeof(A):" << sizeof(A) << std::endl;std::cout << "sizeof(A1):" << sizeof(A1) << std::endl;std::cout << "sizeof(B):" << sizeof(B) << std::endl; std::cout << "sizeof(C):" << sizeof(C) << std::endl; std::cout << "sizeof(D):" << sizeof(D) << std::endl; return 0;
}/*
32位系统下输出：
sizeof(A):1 // 空类A(1)
sizeof(A1):1 // 空类A(0) + A1(1)
sizeof(B):4 // 空类A(0) + 虚函数指针(4)
sizeof(C):4 // 与B共用虚函数指针(4)
sizeof(D):8 // A(1+3<对齐>) + 与B共用虚函数指针(4)
*//*
64位系统下输出：
sizeof(A):1 // 空类A(1)
sizeof(A1):1 // 空类A(0) + A1(1)
sizeof(B):8 // 空类A(0) + 虚函数指针(8)
sizeof(C):8 // 与B共用虚函数指针(8)
sizeof(D):16 // A(1+7<对齐>) + 与B共用虚函数指针(8)
*/

共有继承，共用虚函数指针，没有虚基指针。 

10.虚继承

#include<iostream>/*
虚继承与继承的区别：
1.多了一个虚基指针
2.虚基类位于派生类存储空间的最末尾
3.不会共用虚函数指针
*/class A
{char a[3];
public:virtual void fun1() {};
};// 测试一：单个虚继承，不带虚函数
class B : public virtual A
{char b[3];
};// 测试二：单个虚继承，带自己的虚函数
class C : public virtual A
{char c[3];
public:virtual void fun2() {};
};// 测试三：双重继承
class D : public virtual C
{char d[3];
public:virtual void fun3() {};
};int main()
{std::cout << sizeof(A) << std::endl; std::cout << sizeof(B) << std::endl; std::cout << sizeof(C) << std::endl; std::cout << sizeof(D) << std::endl; return 0;
}/*
32位系统输出：
8 // 8【虚函数指针占4个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个】
16 // 8(A) + 8(B)【8 == (3+1)+虚基指针】
20 // 8(A) + 12(C)【12 == (3+1)+自己的虚函数指针+虚基指针】
32 // (char d[3]占3个字节+对齐另需1个字节)+类D自己的虚函数指针(4个字节)+虚基指针(4个字节)+(char c[3]占3个字节+对齐另需1个字节)+类C自己的虚函数指针(4个字节)+虚基指针(4个字节)+(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个字节) + 类A自己的虚函数指针占4个字节*//*
64位系统输出：
16 // 【虚函数指针占8个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个】
32 // 16(A) + 16【16 == (char b[3]占3个字节+对齐另需5个字节)+虚基指针(8个字节)】
40 // 16(A) + 24【24 == <(char c[3]占3个字节+对齐另需5个字节)+自己的虚函数指针(8个字节)+虚基指针(8个字节)>】
64 // (char d[3]占3个字节+对齐另需5个字节)+类D自己的虚函数指针(8个字节)+虚基指针(8个字节)+(char c[3]占3个字节+对齐另需5个字节)+类C自己的虚函数指针(8个字节)+虚基指针(8个字节)+(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个字节) + 类A自己的虚函数指针占8个字节
*/

        注意，虚继承的时候 A B C D 四个类不仅不会共享虚基类指针，也不会共享虚函数指针，要和普通继承区分开来。

具体分析如下：

 class A size(8):+---0    | {vfptr}4    | a| <alignment member> (size=1)8    +---class B size(16):+---0    | {vfptr}4    | {vbptr}8    | b| <alignment member> (size=1)+---+--- (virtual base A)
12    | a| <alignment member> (size=1)
16    +---class C size(20):+---0    | {vfptr}4    | {vbptr}8    | b| <alignment member> (size=1)+---+--- (virtual base A)
12    | {vfptr}
16    | a| <alignment member> (size=1)
20    +---    class D size(32):+---0    | {vfptr}4    | {vbptr}8    | c| <alignment member> (size=1)+---+--- (virtual base A)
12    | {vfptr}
16    | a| <alignment member> (size=1)+---+--- (virtual base B)
20    | {vfptr}
24    | {vbptr}
28    | b| <alignment member> (size=1)
32    +---

• 虚表（vftable）
• 虚函数指针（vfptr）
• 虚基指针（vbptr）

11.总结

        空的类是会占用内存空间的，而且大小是 1，原因是 C++ 要求每个实例（对象）在内存中都有独一无二的地址。

（一）类内部的成员变量：

• 普通的变量：是要占用内存的，但是要注意对齐原则（这点和 struct 类型很相似）。
• static 修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。

（二）类内部的成员函数：

• 普通函数：不占用内存。
• 虚函数：有一个指向虚函数的指针，要占用 4 个字节或 8 个字节（根据系统位数来定），用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。

（三）虚继承与继承的区别：

• 多了一个虚基指针。
• 虚基类位于派生类存储空间的最末尾。
• 不会共用虚函数指针。

参考自：

C++类对象到底占多大存储空间呢_类的成员函数占用空间吗_haowunanhai的博客-CSDN博客
https://www.cnblogs.com/linuxAndMcu/p/10388330.html

C++中的类所占内存空间总结

c++虚表（vftable）、虚函数指针（vfptr）、虚基指针（vbptr）的测试结果

https://www.cnblogs.com/aqing1987/p/4210773.html