C++中类的内存空间大小（sizeof）分析

 那么在C++中的类的内存空间大小又有哪些特殊的问题呢？

    首先，我认为对齐肯定也是其中的问题之一，对齐主要是为了加快读取的速度。

    关于对齐这个我认为基本上已经是操作系统内定好的，既然Linux与Windows存在差别，那么在C++的类中，关于对齐肯定也会存在一定的差别。关于对齐我认为只要记住平时使用的系统的对齐准则就可以了，即：在Windows中经常是以结构体重最大内置类型的存储单元的字节数作为对齐的基准，而在Linux中，所有的对齐都是以4个字节对齐。

   

    其次，我认为就应该讨论在基类中哪些成员占有存储空间，那些成员不占用内存空间？

    在C++中占存储区间的主要是非static的数据对象，主要包括各种内置的数据类型，类对象等，类中的函数声明以及函数定义都不算内存空间。但是需要注意所有的virtual函数（虚函数）共享一段内存区域，一般来说是4个字节。为什么只是包含非static数据对象呢？因为static数据并不属于类的任何一个对象，它是类的属性，而不是具体某一个对象的属性，在整个内存区域中只有一个内存区域存储对应的static数据，也就是所有的类对象共享这个数据，所以不能算做具体某一个对象或者类型的内存空间。

    因此可以认为基类对象的存储空间大小为：

    非static数据成员的大小 + 4 个字节（虚函数的存储空间）

    当然这个大小不是所有数据成员大小的叠加，而是存在一个对齐问题，具体的应该参考相关的对齐文章。

 

    最后，我认为肯定要关心一下派生类的存储空间了？

    在C++中，继承类是一个比较有用的类，继承使得各种类在基类的基础上扩展，这时候派生类中包含了基类的信息，一般而言，在基类中存在虚函数时，派生类中继承了基类的虚函数，因此派生类中已经继承了派生类的虚函数。因此继承类中不能再添加虚函数的存储空间（因为所有的虚函数共享一块内存区域），而仅仅需要考虑派生类中心添加进来的非static数据成员的内存空间大小。

    因此可以认为派生类对象的存储空间大小为：

    基类存储空间 + 派生类特有的非static数据成员的存储空间

 

   还有一类是比较特殊的情况，如果是虚继承的情况下，这时的存储空间大小就会发生变化。

    基类的存储空间 + 派生类特有的非static数据成员的存储空间 + 每一个类的虚函数存储空间。

  

    下面我采用一些例子说明上面的问题：

    对齐的问题：

点击(此处)折叠或打开

1. class test
   
2. {
3. public:
   
4.         test();
   
5. private:
   
6.         int a;
   
7.         char c;
   
8. };
   
9. 
   
10. cout << sizeof(test) << endl;

  上面的代码在linux以及windows下都会输出8，而不是输出5，这个是在C语言中已经讨论过的话题，但是说明对齐在C++中也是要考虑的。关于操作系统的差异在后面用一个统一的例子说明。

    虚函数问题

    为了讨论虚函数，我们在test类中添加一个虚析构函数，然后再测试结果。   

点击(此处)折叠或打开

1. class test
   
2. {
3. public：
   
4.         test();
   
5.         virtual ~test();
   
6. private:
   
7.         int a;
   
8.         char c;
   
9. };
   
10. cout << sizeof(test) << endl;

这段代码与前面的代码没有什么区别，只是添加了一个虚函数，然后编译调试，这时候输出的结果12，也就是说增加了一个虚函数以后，类的数据成员增加了4个字节，那么是否是每一个虚函数都占有4个字节呢？其实是不会的，在test中加入一个新的虚函数virtual void get_a_c(),这时在输出的结果还是12，这说明所有的虚函数共享4个字节。

    static数据

    我们知道static数据是非对象的属性，而是类的属性，他不能算是某一个对象或者类型的存储空间，在类定义中只能声明，初始化只能在类外执行，当然有例外的。这也不做分析了。具体参看后面的大例子。

    派生类的存储空间

    派生类从基类中继承了很多成员，自己也会增加很多的成员，由于虚函数也会被继承下来，所以就是在派生类中不显式定义虚函数，在派生类中也会存在从基类继承下来的虚函数，因此虚函数不需要额外计算内存空间，而只需要增加基类的非static成员数据大小。定义如下面所示，该函数会输出20，刚好是添加的非static数据double d的存储空间大小。证明了上面的分析。

点击(此处)折叠或打开

1. class test
   
2. {
   
3. public:
   
4.         test();
   
5.         virtual ~test();
   
6.         virtual void get_a_c();
   
7. private:
   
8.         int a;
   
9.         char c;
   
10. };
    
11. 
    
12. class derived_test:public test
    
13. {
    
14. public:
    
15.         virtual ~derived_test();
    
16. private:
    
17.         double d ; 
    
18. };
    
19. 
    
20. cout << sizeof(derived_test) << endl;

测试虚继承的类的大小：

点击(此处)折叠或打开

1. class A
   
2. {
   
3.         char i[3];
   
4. public:
   
5.         virtual void a(){};
   
6. };
   
7. 
   
8. class B : public virtual A
   
9. {
   
10.         char j[3];
    
11. public:
    
12.         virtual void b(){}
    
13. };
    
14. 
    
15. class C: public virtual B
    
16. {
    
17.         char k[3];
    
18. public:
    
19.         virtual void c(){}
    
20. };
    
21. 
    
22. int main()
    
23. {
    
24.     cout << "sizeof(A): " << sizeof(A) << endl;
    
25.     cout << "sizeof(B): " << sizeof(B) << endl;
    
26.     cout << "sizeof(C): " << sizeof(C) << endl;
    
27.     return 0;
    
28. }

下面采用一个比较综合的例子说明一下操作系统以及各种综合的影响分析。

点击(此处)折叠或打开

1. #include <iostream>
   
2. #include <string>
   
3. #include <vector>
   
4. 
   
5. class test
   
6. {
   
7. public:
   
8.     test();
   
9.     virtual ~test();
   
10.     virtual void get_a_c();
    
11. private:
    
12.     int a;
    
13.     char c;
    
14. };
    
15. 
    
16. class derived_test:public test
    
17. {
    
18. public:
    
19.     virtual ~derived_test();
    
20. private:
    
21.     double d ;
    
22. };
    
23. 
    
24. class base
    
25. {
    
26. private:
    
27.     char a;
    
28.     static int refrence_count;
    
29.     std::string name;
    
30.     double price;
    
31.     std::vector<double> dvec;
    
32. public:
    
33.     base();
    
34.     virtual ~base();
    
35.     static int get_count();
    
36. };
    
37. 
    
38. int base::get_count()
    
39. {
    
40.     return refrence_count;
    
41. }
    
42. 
    
43. int base::refrence_count = 0;
    
44. 
    
45. class new_base
    
46. {
    
47. private:
    
48.     char a;
    
49.     double price;
    
50.     std::vector<double> dvec;
    
51.     std::string name;
    
52.     static int refrence_count;
    
53. public:
    
54.     new_base();
    
55.     virtual ~new_base();
    
56.     static int get_count();
    
57. };
    
58. 
    
59. int new_base::get_count()
    
60. {
    
61.     return refrence_count;
    
62. }
    
63. int new_base::refrence_count = 0;
    
64. 
    
65. class derived: public base
    
66. {
    
67. private:
    
68.     int min_qty;
    
69.     double discount;
    
70.     static int newp;
    
71. public:
    
72.     derived();
    
73.     virtual ~derived(){};
    
74. };
    
75. 
    
76. class new_derived:public new_base
    
77. {
    
78. private:
    
79.     double discount;
    
80.     int min_pty;
    
81.     static int newp;
    
82. public:
    
83.     new_derived();
    
84.     virtual ~new_derived(){}
    
85. };
    
86. 
    
87. int main()
    
88. {
    
89.     std::cout << "The size of test is " << sizeof(test) << std::endl; 
    
90.     std::cout << "The size of derived_test is " << sizeof(derived_test) << std::endl; 
    
91.     std::cout << "The size of base is " << sizeof(base) << std::endl; 
    
92.     std::cout << "The size of new_base is " << sizeof(new_base) << std::endl; 
    
93.     std::cout << "The size of derived is " << sizeof(derived) << std::endl; 
    
94.     std::cout << "The size of new_derived is " << sizeof(new_derived) << std::endl;
    
95.     
    
96.     return 0;
    
97. }

上面在windows和linux的结果分别如下：

windows：

Linux：

从上面的结果可以之知道在两个系统下，结果是不一样的。说明操作系统也对类的存储空间大小有较大的影响。