C++整理12_类的组合

类的组合（Class Composition）

类的组合是一种“has-a”关系，指一个类的对象中可以包含其他类的对象作为其成员。组合在面向对象编程中是一种常用的设计策略，用于构建复杂的系统。

1. 类的组合

• 概念：组合是指一个类的对象包含另一个类的对象作为其成员，这表明一种整体与部分的关系。
• 语法：

  class Component {
      // 成员和方法
  };
   
  class Composite {
  private:
      Component part;
  public:
      Composite() {
          // Composite的构造函数
      }
   
      void function() {
          part.function(); // 使用内部的Component对象
      }
  };

• 特点：组合使得Composite类可以管理Component对象的生命周期，并可以控制对Component对象的访问。

示例代码：

#include <iostream>
#include <string>
 
class Person {
public:
    Person(const std::string& name) : name(name) {}
    void speak() const {
        std::cout << name << " says hello!" << std::endl;
    }
 
private:
    std::string name;
};
 
class Classroom {
public:
    Classroom(const std::string& courseName, const Person& teacher)
        : courseName(courseName), teacher(teacher) {}
 
    void startLesson() const {
        std::cout << "Starting " << courseName << std::endl;
        teacher.speak();
    }
 
private:
    std::string courseName;
    Person teacher; // Person对象作为Classroom的成员
};
 
int main() {
    Person teacher("Kimi");
    Classroom classroom("C++ Programming", teacher);
    classroom.startLesson();
    return 0;
}

2. 构造函数的调用顺序

• 概念：在组合中，当创建包含其他对象的类的对象时，需要调用这些成员对象的构造函数来初始化它们。
• 特点：成员对象的构造函数在包含对象的构造函数中通过初始化列表调用，调用顺序是根据它们在类定义中出现的顺序。

示例代码：

#include <iostream>
#include <string>
 
class Engine {
public:
    Engine() {
        std::cout << "Engine constructed" << std::endl;
    }
    ~Engine() {
        std::cout << "Engine destroyed" << std::endl;
    }
};
 
class Car {
private:
    Engine engine;
public:
    Car() : engine() {  // Engine的构造函数通过初始化列表调用
        std::cout << "Car constructed" << std::endl;
    }
    ~Car() {
        std::cout << "Car destroyed" << std::endl;
    }
};
 
int main() {
    Car car;  // 调用Car的构造函数，进而调用Engine的构造函数
    return 0;
}

在这个示例中，当Car对象被创建时，首先会调用Engine对象的构造函数，然后调用Car的构造函数。对象的销毁顺序与构造顺序相反，即首先销毁Car对象，然后是Engine对象。

类的组合是一种强大的设计模式，它允许开发者通过构建和管理对象之间的关系来设计灵活和可重用的类。正确的构造函数和析构函数的编写确保了成员对象的正确初始化和清理。