1. //此代码在32位win下运行成功 
    2.  
         
  2. #include<iostream> 
    3.  
         
  3. using namespace std; 
    4.  
         
  4. class A//A是空类，编译器会用一个char类型标记这个类，大小为1 
    5.  
         
  5. { 
    6.  
         
  6.  
    7.  
         
  7. }; 
    8.  
         
  8. class B:public A//B继承了A，但同样也是空类，大小为1 
    9.  
         
  9. { 
    10.  
         
  10.  
    11.  
         
  11. }; 
    12.  
         
  12. class C:virtual public A//虚拟继承的时候编译器会安插一个指向父类的指针，大小为4 
    13.  
         
  13. { 
    14.  
         
  14.  
    15.  
         
  15. }; 
    16.  
         
  16. class D//大小为4 
    17.  
         
  17. { 
    18.  
         
  18.   public: 
    19.  
         
  19.   int a; 
    20.  
         
  20.   static int b;//静态变量被放在静态存储区 
    21.  
         
  21. }; 
    22.  
         
  22. class E //print函数不占内存空间，大小为4 
    23.  
         
  23. { 
    24.  
         
  24.     public: 
    25.  
         
  25.     void print(){cout<<"E"<<endl;} 
    26.  
         
  26.     private: 
    27.  
         
  27.     int a; 
    28.  
         
  28. }; 
    29.  
         
  29. class F//虚函数会占用一个指针大小的内存，系统需要用这个指针维护虚函数表。大小为8 
    30.  
         
  30. { 
    31.  
         
  31.     public: 
    32.  
         
  32.     virtual void print(){cout<<"F"<<endl;} 
    33.  
         
  33.     private: 
    34.  
         
  34.     int a; 
    35.  
         
  35. }; 
    36.  
         
  36. class G:public F//多了一个虚函数内存大小不变，可见一个类只有一个虚函数指针。大小为8 
    37.  
         
  37. { 
    38.  
         
  38.     public: 
    39.  
         
  39.     virtual void print(){cout<<"G"<<endl;} 
    40.  
         
  40.     virtual void print2(){cout<<"G2"<<endl;} 
    41.  
         
  41. }; 
    42.  
         
  42. int main() 
    43.  
         
  43. { 
    44.  
         
  44.     A a; 
    45.  
         
  45.     B b; 
    46.  
         
  46.     C c; 
    47.  
         
  47.     D d; 
    48.  
         
  48.     E e; 
    49.  
         
  49.     F f; 
    50.  
         
  50.     G g; 
    51.  
         
  51.     cout<<sizeof(A)<<" "<<sizeof(a)<<endl;//1 1 
    52.  
         
  52.     cout<<sizeof(B)<<" "<<sizeof(b)<<endl;//1 1 
    53.  
         
  53.     cout<<sizeof(C)<<" "<<sizeof(c)<<endl;//4 4 
    54.  
         
  54.     cout<<sizeof(D)<<" "<<sizeof(d)<<endl;//4 4 
    55.  
         
  55.     cout<<sizeof(E)<<" "<<sizeof(e)<<endl;//4 4 
    56.  
         
  56.     cout<<sizeof(F)<<" "<<sizeof(f)<<endl;// 8 8 
    57.  
         
  57.     cout<<sizeof(G)<<" "<<sizeof(g)<<endl;//8 8 
    58.  
         
  58.  
    59.  
         
  59.     return 0; 
    60.  
         
  60. } 
    61.