sizeof 的简单总结

转载：https://i-blog.csdnimg.cn/blog_migrate/3f086a1bfcc9dfab0d329b5b8f84dde6.png

对于sizeof，作个简单的总结:

在一个struct或者class里面定义的一些变量，

1、如果是static类型的，则不算入sizeof计算范围(可能是因为创建对象时，static类型不属于某个特定的对象，而是属于这个类所有的对象，它在内存中不是和对象的变量一起存放的)；

2、一般的函数也不算入sizeof计算范围，虚函数则放到一个虚函数表中，有一个虚函数表指针指向这个表格（无论有多少个虚函数，都是加上4 ，记住了）。如果是单继承，则子类的大小是父类的大小加上自己的大小。

3、在一个struct或者class里面定义的变量，如果要计算其大小，那么首先应该找出类型最大的那个，然后以那个大小来进行“内存对齐”，最后就可以得到真实的大小了（一般情况下是这样）。

具体举例如下（部分测试代码来源于：http://blog.csdn.net/fanfanK/article/details/12175585）

[cpp]  view plain copy

1. #include<iostream>  
2. #include<stdio.h>  
3. using namespace std;  
4.   
5. class TwoIntNoVirtual  
6. {  
7.     int a;  
8.     int b;  
9.     void function()  
10.     {  
11.         cout << "Hello" << endl;  
12.     }  
13. };  
14. class TwoIntOneVirtual  
15. {  
16.     int a;  
17.     int b;  
18.     virtual void function()  
19.     {  
20.     }  
21. };  
22. class TwoIntTwoVirtual  
23. {  
24.     int a;  
25.     int b;  
26.     virtual void function()  
27.     {  
28.     }  
29.     virtual void function2()  
30.     {  
31.     }  
32. };  
33. class TwoIntOneVirtualDerived : public TwoIntOneVirtual  
34. {  
35.     void function2()  
36.     {  
37.     }  
38. };  
39. class TwoIntTwoVirtualDerived : public TwoIntTwoVirtual  
40. {  
41.     void function()  
42.     {  
43.     }  
44.     void function2()  
45.     {  
46.     }  
47. };  
48. class OtherTest  
49. {  
50.     char e, f, g, h, i, j, k;  
51.     int a;  
52.     int b;  
53.     int c;  
54.     long long d;  
55.     virtual void function() {}  
56.     virtual void function2() {}  
57. };  
58.   
59. class node0  
60. {  
61. public:  
62.     int a;  
63.     char b;  
64.     short c;  
65.     char d;  
66.     double e;  
67. };  
68.   
69. int main()  
70. {  
71.     cout << "TwoIntNoVirtual: " << sizeof(TwoIntNoVirtual) << endl; // 8  
72.     cout << "TwoIntOneVirtual: " << sizeof(TwoIntOneVirtual) << endl; // 12  
73.     cout << "TwoIntTwoVirtual: " << sizeof(TwoIntTwoVirtual) << endl; // 12  
74.     cout << "TwoIntOneVirtualDerived: " << sizeof(TwoIntOneVirtualDerived) << endl; // 12  
75.     cout << "TwoIntTwoVirtualDerived: " << sizeof(TwoIntTwoVirtualDerived) << endl; // 12  
76.     cout << "OtherTest: " << sizeof(OtherTest) << endl; // 40  
77.     cout << "Long long: " << sizeof(short) << endl; // 2  
78.     cout << "Long long: " << sizeof(long long) << endl; // 8  
79.     cout << "node0: " << sizeof(node0) << endl; // 24  
80.   
81.   
82.     cout << "---------------------" << endl;  
83.     node0 no;  
84.     cout << "&a = " << (void*)&no.a << endl;  
85.     cout << "&b = " << (void*)&no.b << endl;  
86.     cout << "&c = " << (void*)&no.c << endl;  
87.     cout << "&d = " << (void*)&no.d << endl;  
88.     cout << "&e = " << (void*)&no.e << endl;  
89.   
90.     return 0;  
91. }  

在这个例子中，下面这个比较有代表性：

[cpp]  view plain copy

1. class node0  
2. {  
3. public:  
4.     int a;  
5.     char b;  
6.     short c;  //short占2个字节
7.     char d;  
8.     double e;  
9. };  

这里，首先找到大小最大的类型为double，占8个字节，所以应该以8字节的大小来对齐，最后的大小应该是8的整数倍。

现在已经找到最大的为8了，下面就来模拟对上面结构来开内存(以下表格表示内存，地址从上到下、从左到右的方向增加)，表格里的字母表示该地址被字母所表示的变量占据着，空格是为了要对齐才这样的。

再分析一个：

[cpp]  view plain copy

1. class OtherTest  
2. {  
3.     char e, f, g, h, i, j, k;  
4.     int a;  
5.     int b;  
6.     int c;  
7.     long long d;  
8.     virtual void function() {}  
9.     virtual void function2() {}  
10. };  

这里，也是首先找到大小最大的类型，为long long，在Windows7 32位的VS2013上占8个字节，所以应该以8字节的大小来对齐，最后的大小应该是8的整数倍。

现在已经找到最大的为8了，下面就来模拟对上面结构来开内存(以下表格表示内存，地址从上到下、从左到右的方向增加)，表格里的字母表示该地址被字母所表示的变量占据着，空格是为了要对齐才这样的。其中vptr是虚函数表指针，一般占4个字节。所以总共是40字节长。

 

如果是在GCC下，那么sizeof的结果是32，内存如下：