<aside> 💡

组合模式（Composite）：将对象组合成树形结构以表示**“部分-整体”**的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性

</aside>

• 组合模式使得整体和部分可以被一致对待

结构图

• 组件（Component）
  • 组合模式的“根节点”，定义组合中所有对象的通用接口，可以是抽象类或接口。
  • 该类中定义了子类的共性内容。
  • 在透明方式中还声明了接口用于访问和管理Component的子部件（Add、Remove、Display……）
• 叶节点（Leaf）
  • 实现了Component接口的叶子节点，表示组合中的叶子对象，叶子节点没有子节点
• 合成 / 枝节点（Composite）
  • 作用是存储子部件，并且实现了对子部件的相关操作，比如添加、删除、获取子组件等。

透明方式与安全方式

透明方式

• 透明方式中，Component声明了所以用来管理子对象的方法，包括Add、Remove等
• 实现了Component的所有子类都需要实现Add和Remove
  • 优点：叶节点和枝节点对外没有区别，它们具备完全一致的接口
  • 缺点：对于叶节点，实现Add和Remove是没有意义的（叶节点没有子节点）

安全方式

• 安全方式中，只在枝节点Composite中声明用来管理子类对象的方法
  • 优点：Left子类不需要去实现这些方法
  • 缺点：由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便

应用场景

• 组合模式可以使得客户端可以统一处理单个对象和组合对象，无需区分它们之间的差异
  • 当发现需求中体现的是部分与整体层次的结构时
  • 希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象
• 总的来说，组合模式适用于任何需要构建具有部分-整体层次结构的场景，比如组织架构管理、文件系统的文件和文件夹组织等

题目

https://kamacoder.com/problempage.php?pid=1090

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

// Component类
class Company{
protected:
    std::string name;

public:
    Company(std::string name): name(name){}
    virtual ~Company(){}

    // 透明模式，定义了管理子类的接口（add）
    virtual void add(Company*) = 0;
    virtual void display(int depth) = 0;
};

// Composite类
class Department: public Company{
private:
    // 管理子类的容器
    std::vector<Company*> employees;

public:
    Department(std::string name): Company(name){}
    // 析构函数中对所有子类进行销毁
    ~Department(){
        for(Company* employee : employees){
            delete employee;
        }
    }

    // 实现了管理子类的方法
    void add(Company* employee) override {
        employees.push_back(employee);
    }

    void display(int depth) override {
        std::string space(depth * 2, ' ');
        std::cout << space << name << std::endl;
        for(Company* employee : employees){
            employee->display(depth + 1);
        }
    }
};

// Left类
class Employee: public Company{
public:
    Employee(std::string name): Company(name){}

    // 叶节点没有子类，也不需要对其进行管理，实现该接口是没有意义的
    void add(Company*) override {
        std::cout << "Cannot add!" << std::endl;
    }

    void display(int depth){
        std::string space(depth * 2, ' ');
        std::cout << space << name << std::endl;
    }
};

int main(){
    std::string companyName;
    std::cin >> companyName;
    Department* myCompany = new Department(companyName);
    Department* department = nullptr;

    int n;
    std::cin >> n;
    for(int i = 0; i < n; ++i){
        std::string type;
        std::string name;
        std::cin >> type >>name;

        if(type == "D"){
            department = new Department(name);
            myCompany->add(department);
        }else if(type == "E"){
            department->add(new Employee(name));
        }
    }

    std::cout << "Company Structure:" << std::endl;
    myCompany->display(0);

    // 只需要销毁根节点，子类由其析构函数负责销毁
    delete myCompany;

    return 0;
}