类大小计算

首先来个总结，然后下面给出实际例子，实战！

  • 空类的大小为1字节
  • 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
  • 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
  • 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
  • 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！
  • 虚继承,继承基类的vptr。

1.原则1

  1. /**
  2.  * @file blackclass.cpp
  3.  * @brief 空类的大小为1字节
  4.  * @author 光城
  5.  * @version v1
  6.  * @date 2019-07-21
  7.  */
  8. #include<iostream>
  9. using namespace std;
  10. class A{};
  11. int main()
  12. {
  13.     cout<<sizeof(A)<<endl;
  14.     return 0;
  15. }

2.原则2

  1. /**
  2.  * @file static.cpp
  3.  * @brief 静态数据成员
  4.  * 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。 
  5.  * @author 光城
  6.  * @version v1
  7.  * @date 2019-07-21
  8.  */
  9. #include<iostream>
  10. using namespace std;
  11. class A
  12. {
  13.     public:
  14.         char b;
  15.         virtual void fun() {};
  16.         static int c;
  17.         static int d;
  18.         static int f;
  19. };
  21. int main()
  22. {
  23.     /**
  24.      * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
  25.      */
  26.     cout<<sizeof(A)<<endl; 
  27.     return 0;
  28. }

3.原则3

  1. /**
  2.  * @file morevir.cpp
  3.  * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
  4.  * @author 光城
  5.  * @version v1
  6.  * @date 2019-07-21
  7.  */
  8. #include<iostream>
  9. using namespace std;
  10. class A{
  11.     virtual void fun();
  12.     virtual void fun1();
  13.     virtual void fun2();
  14.     virtual void fun3();
  15. };
  16. int main()
  17. {
  18.     cout<<sizeof(A)<<endl; // 8
  19.     return 0;
  20. }

4.原则4与5

  1. /**
  2.  * @file geninhe.cpp
  3.  * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
  4.  * 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。
  5.  * 2.虚单继承，派生类继承基类vptr
  6.  * @author 光城
  7.  * @version v1
  8.  * @date 2019-07-21
  9.  */
  11. #include<iostream>
  13. using namespace std;
  15. class A
  16. {
  17.     public:
  18.         char a;
  19.         int b;
  20. };
  22. /**
  23.  * @brief 此时B按照顺序：
  24.  * char a
  25.  * int b
  26.  * short a
  27.  * long b
  28.  * 根据字节对齐4+4=8+8+8=24
  29.  */
  30. class B:A
  31. {
  32.     public:
  33.         short a;
  34.         long b;
  35. };
  36. class C
  37. {
  38.     A a;
  39.     char c;
  40. };
  41. class A1
  42. {
  43.     virtual void fun(){}
  44. };
  45. class C1:public A
  46. {
  47. };
  49. int main()
  50. {
  51.     cout<<sizeof(A)<<endl; // 8
  52.     cout<<sizeof(B)<<endl; // 24
  53.     cout<<sizeof(C)<<endl; // 12
  54.     /**
  55.      * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
  56.      */
  57.     cout<<sizeof(C1)<<endl; // 8 
  58.     return 0;
  59. }

5.原则6

  1. /**
  2.  * @file virnhe.cpp
  3.  * @brief 虚继承
  4.  * @author 光城
  5.  * @version v1
  6.  * @date 2019-07-21
  7.  */
  9. #include<iostream>
  10. using namespace std;
  11. class A
  12. {
  13.     virtual void fun() {}
  14. };
  15. class B
  16. {
  17.     virtual void fun2() {}
  18. };
  19. class C : virtual public  A, virtual public B
  20. {
  21.     public:
  22.         virtual void fun3() {}
  23. };
  25. int main()
  26. {
  27.     /**
  28.      * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
  29.      */
  30.     cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
  32.     return 0;
  33. }