组合模式（Composite Pattern）

组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

组合模式主要解决的是在需要表示一个对象整体与部分的层次结构时，通过该模式可以使客户端程序可以统一地处理单个对象和组合对象。这样，客户端代码可以以相同的方式处理组合对象和单个对象。

主要特点

1. 统一接口：组合模式定义了一个统一的接口，用于表示叶节点和组合对象。
2. 递归组合：组合对象可以包含其他组合对象或叶节点，通过递归结构来构建复杂的层次结构。
3. 透明性：客户端可以一致地使用组合对象和叶节点，而不需要关心它们是单个对象还是组合对象。

示例

假设我们要实现一个公司组织架构，其中包含部门和员工。部门可以包含子部门和员工，员工是最基本的元素。我们可以使用组合模式来实现这个需求。

#include <iostream>
#include <vector>
#include <memory>
#include <string>

// Component 基类
class Employee {
public:
    virtual ~Employee() {}
    virtual void showDetails() const = 0;
};

// Leaf 类
class Developer : public Employee {
public:
    Developer(const std::string &name, const std::string &position)
        : name(name), position(position) {}

    void showDetails() const override {
        std::cout << "Developer: " << name << ", " << position << std::endl;
    }

private:
    std::string name;
    std::string position;
};

class Manager : public Employee {
public:
    Manager(const std::string &name, const std::string &position)
        : name(name), position(position) {}

    void showDetails() const override {
        std::cout << "Manager: " << name << ", " << position << std::endl;
    }

private:
    std::string name;
    std::string position;
};

// Composite 类
class Department : public Employee {
public:
    Department(const std::string &name) : name(name) {}

    void addEmployee(std::shared_ptr<Employee> employee) {
        employees.push_back(employee);
    }

    void showDetails() const override {
        std::cout << "Department: " << name << std::endl;
        for (const auto &employee : employees) {
            employee->showDetails();
        }
    }

private:
    std::string name;
    std::vector<std::shared_ptr<Employee>> employees;
};

// 主函数测试
int main() {
    auto dev1 = std::make_shared<Developer>("John", "Senior Developer");
    auto dev2 = std::make_shared<Developer>("Doe", "Junior Developer");
    auto mgr1 = std::make_shared<Manager>("Alice", "Project Manager");

    auto engineering = std::make_shared<Department>("Engineering");
    engineering->addEmployee(dev1);
    engineering->addEmployee(dev2);
    engineering->addEmployee(mgr1);

    auto hr1 = std::make_shared<Manager>("Bob", "HR Manager");
    auto hr = std::make_shared<Department>("Human Resources");
    hr->addEmployee(hr1);

    auto company = std::make_shared<Department>("Company");
    company->addEmployee(engineering);
    company->addEmployee(hr);

    company->showDetails();

    return 0;
}

解释

1. Employee：这是一个抽象基类，定义了一个纯虚函数showDetails，表示员工的详细信息。

2. Developer和Manager：这两个类是叶节点，实现了Employee接口的showDetails方法，分别展示开发人员和经理的详细信息。

3. Department：这是组合类，它包含多个Employee对象，可以是Developer、Manager或其他Department。它实现了Employee接口的showDetails方法，展示部门及其所有子员工的详细信息。

4. 主函数：

   • 创建开发人员和经理的实例。
   • 创建部门实例，并将员工添加到部门中。
   • 创建公司实例，并将部门添加到公司中。
   • 调用company->showDetails()来展示公司及其所有部门和员工的详细信息。

总结

组合模式通过将对象组合成树形结构，能够一致地对待单个对象和组合对象，适用于需要表示“部分-整体”关系的场景。通过这种模式，可以轻松地扩展系统而不会影响客户端代码，同时保持代码的清晰和简洁。