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

    前言

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

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. class A {
    5.  
    6. };
    7.  
    8. int main() {
    9. 	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
    10. 	// 定义两个对象a1,a2
    11. 	A a1;
    12. 	A a2;
    13. 	cout << "由类A实例化后的对象a1的地址：" << &a1 << endl;
    14. 	cout << "由类A实例化后的对象a2的地址：" << &a2 << endl;
    15. 	
    16. 	system("pause");
    17. 	return 0;
    18. }

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

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. class A {
    5. 	int a; // int类型变量a
    6. 	char p; // char类型变量p
    7. };
    8.  
    9. int main() {
    10. 	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
    11. 	system("pause");
    12. 	return 0;
    13. }

    输出结果： 

     

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

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. class A {
    5. public:
    6.         A(){} // 构造函数
    7.         ~A(){} // 析构函数
    8.         int func1(){ return 0;} // 普通成员函数
    9.         int func2(){ return 0;} // 普通成员函数
    10. };
    11.  
    12.  
    13. int main(){
    14.   cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
    15.  
    16.   return 0;
    17. }

    输出结果： 

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

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. class A {
    5. public:
    6. 	A() {} // 构造函数
    7. 	~A(){} // 析构函数
    8. 	int func1() { return 0; } // 普通成员函数
    9. 	int func2() { return 0; } // 普通成员函数
    10. 	
    11. private:
    12. 	static int num; // 类的静态成员变量
    13. };
    14.  
    15. int main() {
    16. 	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
    17. 	
    18. 	system("pause");
    19. 	return 0;
    20. }

    输出结果： 

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

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. class A {
    5. public:
    6. 	A() {} // 构造函数
    7. 	~A(){} // 析构函数
    8. 	int func1() { return 0; } // 普通成员函数
    9. 	int func2() { return 0; } // 普通成员函数
    10.  
    11. 	// 3个虚函数
    12. 	virtual int func3() { return 0; }
    13. 	virtual int func4() { return 0; }
    14. 	virtual int func5() { return 0; }
    15. 	virtual int func6() { return 0; }
    16. private:
    17. 	static int num; // 类的静态成员变量
    18. };
    19.  
    20. int main() {
    21. 	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
    22. 	
    23. 	system("pause");
    24. 	return 0;
    25. }

    输出结果：

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

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

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

    6.继承 — 子类所占空间

    1. #include
    2. class CBase // 基类
    3. {
    4. public:
    5. 	CBase(void); // 构造函数不占空间
    6. 	virtual ~CBase(void); // 虚析构函数占空间，所占空间根据系统位数而定
    7.  
    8. private:
    9. 	int  a; // 普通变量占空间（4字节）
    10. 	char* p; // 指针类型变量占空间，根据系统位数而定
    11. };
    12.  
    13. class CChild : public CBase // 子类CChild继承Cbase
    14. {
    15. public:
    16. 	CChild(void); // 不占空间
    17. 	~CChild(void); // 不占空间
    18.  
    19. 	virtual void test();// 父类子类共享一个虚函数指针
    20.  
    21. private:
    22. 	int b;
    23. };
    24.  
    25. int main() {
    26. 	char* str;
    27. 	std::cout << sizeof(str) << std::endl;
    28. 	std::cout << sizeof(CBase) << std::endl;
    29. 	std::cout << sizeof(CChild) << std::endl;
    30. }
    31.  
    32. /*
    33. 32位系统下：
    34. 4 // 指针类型变量占4字节
    35. 12 // 虚析构函数指针占4字节+int a变量占4个字节+char* p占4个字节
    36. 16 // int类型变量b占4个字节+基类所占的12个字节
    37.    // virtual void test();此时不占空间，原因是：父类子类共享一个虚函数指针
    38. */
    39.  
    40. /*
    41. 64位系统下：
    42. 8 // 指针类型变量占8字节
    43. 24 // 虚析构函数指针占8字节+(int a变量占4个字节+对齐另需4字节)+(char* p占4个字节+对齐另需4字节)
    44. 32 // (int类型变量b占4个字节+对齐另需4个字节)+基类所占的24个字节
    45. */
    46.  
    47.  
    48.

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

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

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class A {};
    6.  
    7. class A2 {};
    8.  
    9. class B : public A {};
    10.  
    11. class C : public A, public A2 {};
    12.  
    13. class D : public virtual B {}; // 虚继承
    14.  
    15.  
    16. int main()
    17. {
    18.     cout << sizeof(A) << endl;
    19.     cout << sizeof(B) << endl;
    20.     cout << sizeof(C) << endl;
    21.     cout << sizeof(D) << endl;
    22.  
    23.     return 0;
    24.  
    25. }
    26.  
    27. // 32位系统输出：
    28. /*
    29. 1
    30. 1
    31. 1
    32. 4
    33. */
    34.  
    35. // 64位系统输出：
    36. /*
    37. 1
    38. 1
    39. 1
    40. 8
    41. */

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

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

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class A {};
    6.  
    7. class A1 {};
    8.  
    9. class B : public A {
    10.     int b;
    11. };
    12.  
    13. class C : public A, public A1 {
    14.     int c;
    15. };
    16.  
    17.  
    18.  
    19. int main()
    20. {
    21.     cout << sizeof(A) << endl;
    22.     cout << sizeof(B) << endl;
    23.     cout << sizeof(C) << endl;
    24.     return 0;
    25.  
    26. }
    27.  
    28. // 32位系统输出：
    29. /*
    30. 1
    31. 4
    32. 8
    33. */
    34.  
    35. // 64位系统输出：
    36. /*
    37. 1
    38. 4
    39. 8
    40. */

    9.共有继承

    1. #include 
    2.  
    3. class A {
    4. };
    5.  
    6. class A1 : public A {
    7. };
    8.  
    9. class B : public A{
    10. 	virtual void fun() = 0; // 定义虚函数
    11. };
    12.  
    13. // 共有继承，共用虚函数指针，没有虚基指针
    14. class C : public B{
    15. };
    16.  
    17. class D : public A, public B{
    18. };
    19.  
    20. int main()
    21. {
    22. 	std::cout << "sizeof(A):" << sizeof(A) << std::endl;
    23. 	std::cout << "sizeof(A1):" << sizeof(A1) << std::endl;
    24. 	std::cout << "sizeof(B):" << sizeof(B) << std::endl; 
    25. 	std::cout << "sizeof(C):" << sizeof(C) << std::endl; 
    26. 	std::cout << "sizeof(D):" << sizeof(D) << std::endl; 
    27.  
    28. 	return 0;
    29. }
    30.  
    31. /*
    32. 32位系统下输出：
    33. sizeof(A):1 // 空类A(1)
    34. sizeof(A1):1 // 空类A(0) + A1(1)
    35. sizeof(B):4 // 空类A(0) + 虚函数指针(4)
    36. sizeof(C):4 // 与B共用虚函数指针(4)
    37. sizeof(D):8 // A(1+3<对齐>) + 与B共用虚函数指针(4)
    38. */
    39.  
    40. /*
    41. 64位系统下输出：
    42. sizeof(A):1 // 空类A(1)
    43. sizeof(A1):1 // 空类A(0) + A1(1)
    44. sizeof(B):8 // 空类A(0) + 虚函数指针(8)
    45. sizeof(C):8 // 与B共用虚函数指针(8)
    46. sizeof(D):16 // A(1+7<对齐>) + 与B共用虚函数指针(8)
    47. */

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

    10.虚继承

    1. #include
    2.  
    3. /*
    4. 虚继承与继承的区别：
    5. 1.多了一个虚基指针
    6. 2.虚基类位于派生类存储空间的最末尾
    7. 3.不会共用虚函数指针
    8. */
    9.  
    10. class A
    11. {
    12. 	char a[3];
    13. public:
    14. 	virtual void fun1() {};
    15. };
    16.  
    17. // 测试一：单个虚继承，不带虚函数
    18. class B : public virtual A
    19. {
    20. 	char b[3];
    21. };
    22.  
    23. // 测试二：单个虚继承，带自己的虚函数
    24. class C : public virtual A
    25. {
    26. 	char c[3];
    27. public:
    28. 	virtual void fun2() {};
    29. };
    30.  
    31. // 测试三：双重继承
    32. class D : public virtual C
    33. {
    34. 	char d[3];
    35. public:
    36. 	virtual void fun3() {};
    37. };
    38.  
    39. int main()
    40. {
    41. 	std::cout << sizeof(A) << std::endl; 
    42. 	std::cout << sizeof(B) << std::endl; 
    43. 	std::cout << sizeof(C) << std::endl; 
    44. 	std::cout << sizeof(D) << std::endl; 
    45. 	return 0;
    46. }
    47.  
    48. /*
    49. 32位系统输出：
    50. 8 // 8【虚函数指针占4个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个】
    51. 16 // 8(A) + 8(B)【8 == (3+1)+虚基指针】
    52. 20 // 8(A) + 12(C)【12 == (3+1)+自己的虚函数指针+虚基指针】
    53. 32 // (char d[3]占3个字节+对齐另需1个字节)+类D自己的虚函数指针(4个字节)+虚基指针(4个字节)
    54.       +(char c[3]占3个字节+对齐另需1个字节)+类C自己的虚函数指针(4个字节)+虚基指针(4个字节)
    55. 	  +(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个字节) + 类A自己的虚函数指针占4个字节
    57. */
    58.  
    59. /*
    60. 64位系统输出：
    61. 16 // 【虚函数指针占8个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个】
    62. 32 // 16(A) + 16【16 == (char b[3]占3个字节+对齐另需5个字节)+虚基指针(8个字节)】
    63. 40 // 16(A) + 24【24 == <(char c[3]占3个字节+对齐另需5个字节)+自己的虚函数指针(8个字节)+虚基指针(8个字节)>】
    64. 64 // (char d[3]占3个字节+对齐另需5个字节)+类D自己的虚函数指针(8个字节)+虚基指针(8个字节)
    65.       +(char c[3]占3个字节+对齐另需5个字节)+类C自己的虚函数指针(8个字节)+虚基指针(8个字节)
    66. 	  +(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个字节) + 类A自己的虚函数指针占8个字节
    67. */

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

    具体分析如下：

    1.  class A size(8):
    2.       +---
    3.  0    | {vfptr}
    4.  4    | a
    5.       |  (size=1)
    6.  8    +---
    7.  
    8.  class B size(16):
    9.       +---
    10.  0    | {vfptr}
    11.  4    | {vbptr}
    12.  8    | b
    13.       |  (size=1)
    14.       +---
    15.       +--- (virtual base A)
    16. 12    | a
    17.       |  (size=1)
    18. 16    +---
    19.     
    20.  class C size(20):
    21.       +---
    22.  0    | {vfptr}
    23.  4    | {vbptr}
    24.  8    | b
    25.       |  (size=1)
    26.       +---
    27.       +--- (virtual base A)
    28. 12    | {vfptr}
    29. 16    | a
    30.       |  (size=1)
    31. 20    +---    
    32.  
    33.  class D size(32):
    34.       +---
    35.  0    | {vfptr}
    36.  4    | {vbptr}
    37.  8    | c
    38.       |  (size=1)
    39.       +---
    40.       +--- (virtual base A)
    41. 12    | {vfptr}
    42. 16    | a
    43.       |  (size=1)
    44.       +---
    45.       +--- (virtual base B)
    46. 20    | {vfptr}
    47. 24    | {vbptr}
    48. 28    | b
    49.       |  (size=1)
    50. 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 

  • 相关阅读:
    JS迭代器及异步
    【2023年11月第四版教材】第17章《干系人管理》（合集篇）
    50、Spring WebFlux 的 自动配置 的一些介绍，与 Spring MVC 的一些对比
    达梦数据库MAIN表空间导致磁盘满问题的处理和总结
    PLINK相关性分析，分类变量和连续型变量
    IEDA代码模板
    [激光原理与应用-28]：《激光原理与技术》-14- 激光产生技术 - 激光的主要参数与指标
    当我们谈论量化时，我们在谈论什么？量化投资常见策略有哪些？| 融券T0和高频交易详解【邢不行】
    04 多表查询
    jsp196ssm毕业设计选题管理系统hsg4361B6
  • 原文地址：https://blog.csdn.net/m0_48241022/article/details/133936526