基本概念

有成员对象的类叫做封闭类

  1. #include <bits/stdc++.h>
  2. using namespace std;
  4. class tyre
  5. {
  6. private:
  7.     int radius, width;
  9. public:
  10.     tyre(int, int);
  11.     ~tyre(void);
  12.     void PutTyre(void);
  13. };
  15. class engine
  16. {
  17. private:
  18.     int power;
  20. public:
  21.     engine(int);
  22.     ~engine(void);
  23.     void PutEngine(void);
  24. };
  26. class car
  27. {
  28. private:
  29.     int price;
  30.     tyre Ty;
  31.     engine En;
  33. public:
  34.     car(int, int, int, int);
  35.     ~car(void);
  36.     void PutCar(void);
  37. };
  39. tyre::tyre(int r, int w)
  40. {
  41.     radius = r;
  42.     width = w;
  43. }
  45. tyre::~tyre(void)
  46. {}
  48. void tyre::PutTyre(void)
  49. {
  50.     cout << radius << endl;
  51.     cout << width << endl;
  52. }
  54. engine::engine(int p)
  55. {
  56.     power = p;
  57. }
  59. engine::~engine(void)
  60. {}
  62. void engine::PutEngine(void)
  63. {
  64.     cout << power << endl;
  65. }
  67. car::car(int p, int Tr, int Tw, int Ep):price(p),Ty(Tr,Tw),En(Ep){}
  68. //构造函数的另一种写法：初始化列表
  70. car::~car(void)
  71. {}
  73. void car::PutCar(void)
  74. {
  75.     cout << price << endl;
  76.     Ty.PutTyre();
  77.     En.PutEngine();
  78. }
  80. int main(void)
  81. {
  82.     car C(20000, 25, 227, 5000);
  83.     C.PutCar();//20000 25 227 5000
  84.     return 0;
  85. }

7.PNG
备注：原网课的课件里engine类没有自定义构造函数，而我这里自己写了一个，就当“car.engine的初始化没问题”这句话不存在，因为在我这里如果不写构造函数这两个对象如何初始化编译器都不会知道
**

封闭类构造函数和析构函数的执行顺序

8.PNG

  1. #include <bits/stdc++.h>
  2. using namespace std;
  4. class tyre
  5. {
  6. private:
  7.     int radius, width;
  9. public:
  10.     tyre(int, int);
  11.     ~tyre(void);
  12.     void PutTyre(void);
  13. };
  15. class engine
  16. {
  17. private:
  18.     int power;
  20. public:
  21.     engine(int);
  22.     ~engine(void);
  23.     void PutEngine(void);
  24. };
  26. class car
  27. {
  28. private:
  29.     int price;
  30.     tyre Ty;
  31.     engine En;
  33. public:
  34.     car(int, int, int, int);
  35.     ~car(void);
  36.     void PutCar(void);
  37. };
  39. tyre::tyre(int r, int w)
  40. {
  41.     radius = r;
  42.     width = w;
  43.     cout << "Tyre Constructed" << endl;
  44. }
  46. tyre::~tyre(void)
  47. {
  48.     cout << "Tyre Destructed" << endl;
  49. }
  51. void tyre::PutTyre(void)
  52. {
  53.     cout << radius << endl;
  54.     cout << width << endl;
  55. }
  57. engine::engine(int p)
  58. {
  59.     power = p;
  60.     cout << "Engine Constructed" << endl;
  61. }
  63. engine::~engine(void)
  64. {
  65.     cout << "Engine Destructed" << endl;
  66. }
  68. void engine::PutEngine(void)
  69. {
  70.     cout << power << endl;
  71. }
  73. car::car(int p, int Tr, int Tw, int Ep) : price(p), En(Ep), Ty(Tr, Tw)
  74. {
  75.     cout << "Car Constructed" << endl;
  76. }//初始化列表顺序和成员对象声明顺序不一致，构造函数的调用根据成员对象声明顺序来
  78. car::~car(void)
  79. {
  80.     cout << "Car Destructed" << endl;
  81. }
  83. void car::PutCar(void)
  84. {
  85.     cout << price << endl;
  86.     Ty.PutTyre();
  87.     En.PutEngine();
  88. }
  90. int main(void)
  91. {
  92.     car C(20000, 25, 227, 5000);
  93.     C.PutCar();
  94.     return 0;
  95. }
  97. /*
  98. Tyre Constructed
  99. Engine Constructed
  100. Car Constructed  //构造函数由内而外调用
  101. 20000
  102. 25
  103. 227
  104. 5000
  105. Car Destructed
  106. Engine Destructed
  107. Tyre Destructed   //析构函数由外而内调用
  108. */

封闭类的复制构造函数

  1. #include <bits/stdc++.h>
  2. using namespace std;
  4. class A
  5. {
  6. public:
  7.     A(void) { cout << "Default" << endl; }
  8.     A(const A &a) { cout << "Copy" << endl; }
  9. };
  11. class B
  12. {
  13. public:
  14.     A a;
  15. };
  17. int main(void)
  18. {
  19.     B b1;//Default
  20.     B b2(b1);//Copy
  21.     return 0;
  22. }
  • 特殊：调用类B的复制构造函数（编译器自带的）初始化b2时不是简单地把b1拷贝过来，而是会调用A类中的复制构造函数初始化b2的对象a，调用函数时的实参就是b1的对象a
  • 一般：调用封闭类的复制构造函数进行初始化时，封闭类中的成员对象的复制构造函数也会被调用来完成封闭类的复制构造