类类型的大小

1：先看一个空类的大小：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. using namespace std;  
3. class A  
4. {  
5. };   
6. int main(int argc, char** argv) {  
7.     cout<<sizeof(A)<<endl;  
8.     return 0;  
9. }  

sizeof(A)的结果为1；

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. using namespace std;  
3. class A  
4. {  
5.     public:  
6.         A();  
7.         ~A();  
8. };   
9. int main(int argc, char** argv) {  
10.     cout<<sizeof(A)<<endl;  
11.     return 0;  
12. }  

sizeof(A)的结果照样为1；

 

首先，说类的大小本质上是说类的实例的大小，类只是一个类型定义，它是没有大小可言的，用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小；

calss A; A a; szieof(A) == sizeof(a);但是这样编译在编译器当中编译不通过。

上面为什么sizeof(A)的结果为1呢？

(1)因为一个空类也要实例化，所谓类的实例化就是在内存中分配一块地址，每个实例在内存当中都有独一无二的地址。同样空类也要被实例化，所以编译器会给空类

添加一个隐含的字节，这样空类实例化后就有了独一无二的地址了。

(2)而析构函数，跟构造函数这些成员函数，是跟sizeof无关的，也不难理解因为我们的sizeof是针对实例，而普通成员函数，是针对类体的，一个类的成员函数，多个实例也

用相同的函数指针，所以自然不能归为实例的大小。

 

带参数类型的大小：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2.   
3. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
4. using namespace std;   
5.   
6.   
7. class A{  
8.     public:  
9.     int a;  
10.     A()  
11.     {  
12.     }  
13.     ~A()  
14.     {  
15.     }  
16. };  
17. int main(int argc, char** argv) {  
18.     A a;  
19.     cout<<sizeof(A)<<endl;  
20.     return 0;  
21. }  

sizeof(A) = 4;

 

带静态类型参数的大小：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2.   
3. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
4. using namespace std;   
5.   
6.   
7. class A{  
8.     public:  
9.     static int a;  
10.     A()  
11.     {  
12.     }  
13.     ~A()  
14.     {  
15.     }  
16. };  
17. int main(int argc, char** argv) {  
18.     A a;  
19.     cout<<sizeof(A)<<endl;  
20.     return 0;  
21. }  

sizeof(A) = 1;

类的静态数据成员被编译器放在程序的一个global  data members中，它是类的一个数据成员．但是它不影响类的大小，不管这个类实际产生了多少实例，还是派生了多少新的类，静态成员数据在类中永远只有一个实体存在，而类的非静态数据成员只有被实例化的时候，他们才存在．但是类的静态数据成员一旦被声明，无论类是否被实例化，它都已存在．可以这么说，类的静态数据成员是一种特殊的全局变量．

 

带一个虚函数类型的大小：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2.   
3. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
4. using namespace std;   
5.   
6.   
7. class A{  
8.     public:  
9.   
10.     A()  
11.     {  
12.     }  
13.     virtual ~A()  
14.     {  
15.     }  
16. };  
17. int main(int argc, char** argv) {  
18.     A a;  
19.     cout<<sizeof(A)<<endl;  
20.     return 0;  
21. }  

sizeof(A) = 4;

 

带多个虚函数的大小

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2.   
3. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
4. using namespace std;   
5.   
6.   
7. class A{  
8.     public:  
9.   
10.     A()  
11.     {  
12.     }  
13.     virtual void fun()  
14.     {  
15.     }  
16.     virtual ~A()  
17.     {  
18.     }  
19. };  
20. int main(int argc, char** argv) {  
21.     A a;  
22.     cout<<sizeof(A)<<endl;  
23.     return 0;  
24. }  

sizeof(A) = 4;

如果在类中声明了虚函数（不管是1个还是多个），那么在实例化对象时，编译器会自动在对象里安插一个指针指向虚函数表VTable，在32位机器上，一个对象会增加4个字节来存储此指针，它是实现面向对象中多态的关键。而虚函数本身和其他成员函数一样，是不占用对象的空间的.

 

再看下面一段代码：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2.   
3. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
4. using namespace std;   
5.   
6.   
7. class A{  
8. };  
9. class B{  
10.     char c;  
11. };  
12. class C{  
13.     char a;  
14.     char b;  
15.     virtual ~C()  
16.     {  
17.     }  
18. };  
19.   
20. class D{  
21.     int a;  
22.     void fun()  
23.     {  
24.         int m;  
25.     }  
26.       
27. };  
28. int main(int argc, char** argv) {  
29.   
30.     cout<<sizeof(A)<<endl; //1  
31.     cout<<sizeof(B)<<endl; //1  
32.     cout<<sizeof(C)<<endl; //8  
33.     cout<<sizeof(D)<<endl; //4  
34.       
35.       
36.     return 0;  
37. }  

输出 1 1 8 4；

结合这个实例  我们可以得出以下结论：

在一个类中，普通成员函数，构造函数，析构函数，所有的虚函数，以及静态成员变量都是不占用类对象的内存空间的。

一个类对象的大小  等于 VPTR（虚函数指针）+ 非静态数据成员变量 + 内存对其时候的扩展内存大小！

类的总大小也遵守类似class 4字节对齐的

 

继承的类的大小：

[cpp]  view plain  copy

 print ?

1. <span style="color:#000000;">#include <iostream>  
2.   
3. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
4. using namespace std;   
5.   
6.   
7. class A{  
8.     static int a;  
9. };  
10. class B : public A  
11. {  
12.     public:  
13.         virtual int getNun()  
14.         {  
15.             return 10;  
16.         }  
17.     private:  
18.         char* p;  
19. };  
20.   
21. class C: public B  
22. {  
23.     public:  
24.           
25.         int getNum()  
26.         {  
27.             return 3;  
28.         }  
29.       
30.     B b;  
31. };  
32.   
33. int main(int argc, char** argv) {  
34.   
35.     cout<<sizeof(A)<<endl; //1  
36.     cout<<sizeof(B)<<endl; //8  
37.     cout<<sizeof(C)<<endl; //16  
38.     return 0;  
39. }</span>  

1.类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑。

2.普通成员函数与sizeof无关。

3.虚函数由于要维护在虚函数表，所以要占据一个指针大小，也就是4字节。

4.类的总大小也遵守类似class字节对齐的，调整规则