1.8 组合模式（Composite Pattern）

定义

组合模式（Composite Pattern） 是一种结构型设计模式，它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式让客户端可以以相同的方式对待单个对象和对象集合。组合模式使得客户可以统一处理树形结构中的单个对象和对象的集合，简化了对象的使用和管理。

特性

• 树形结构：组合模式通过将多个对象组织成树形结构，使得客户可以通过一致的方式访问单个对象和对象集合。
• 统一接口：组合模式为所有对象提供一个共同的接口，让客户端以相同的方式处理叶子节点（单个对象）和组合节点（包含子对象的节点）。
• 递归结构：组合模式通常使用递归的方式来处理树形结构中的节点。

场景

适用场景

• 树形结构：当对象有部分-整体的层次关系时，组合模式可以提供统一的管理方式。例如，文件夹和文件的关系，组织结构的管理等。
• 需要统一处理叶子节点和组合节点的场景：当你需要统一处理单个对象和多个对象（集合）时，组合模式能够简化代码结构，避免大量的 if 或 switch 语句来分别处理单个对象和集合对象。
• UI组件结构：在构建图形用户界面（GUI）时，组件和容器通常呈现树形结构，可以使用组合模式来统一管理。

应用场景

• 文件系统：文件和文件夹之间具有“部分-整体”关系，文件夹中可以包含多个文件和子文件夹，组合模式可以帮助管理这一层次结构。
• UI组件：在GUI系统中，窗口、面板、按钮、标签等组件组成复杂的界面结构，组合模式能帮助统一管理这些组件。
• 组织结构：公司、部门、员工等可以构成树形结构，组合模式可以简化部门和员工的管理。

类设计

组合模式通常包括以下几个角色：

1. Component（组件）：定义叶子对象和组合对象的共同接口。它通常是一个抽象类或接口，声明了用于处理子对象的方法。
2. Leaf（叶子节点）：叶子对象没有子节点，表示组合中的基本元素，它实现了 Component 接口。
3. Composite（组合节点）：组合对象可以包含子对象（叶子节点或其他组合节点），它也实现了 Component 接口，并包含管理子对象的相关方法。

代码实现

我们以一个 组织结构（部门和员工）为例来演示组合模式。公司有多个部门，每个部门包含多个员工。部门本身也是一个对象，它可以包含其他部门（子部门）和员工（叶子节点）。

1. 定义组件接口（Component）

#include 
#include 
#include 
using namespace std;

// 组件接口：部门和员工的共同接口
class IComponent {
public:
    virtual void showInfo() = 0;  // 显示信息
    virtual ~IComponent() {}
};

• IComponent 是所有部门和员工的公共接口，声明了 showInfo() 方法，用于展示信息。

2. 定义叶子节点类（Employee）

class Employee : public IComponent {
private:
    string name;
    string position;

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

    void showInfo() override {
        cout << "Employee: " << name << ", Position: " << position << endl;
    }
};

• Employee 类代表组织结构中的叶子节点，即员工。
• 每个员工有姓名和职位，showInfo() 方法显示员工的基本信息。

3. 定义组合节点类（Department）

class Department : public IComponent {
private:
    string name;
    vector<IComponent*> children;  // 子组件：可以是员工或子部门

public:
    Department(const string& name) : name(name) {}

    void add(IComponent* component) {
        children.push_back(component);  // 添加子部门或员工
    }

    void showInfo() override {
        cout << "Department: " << name << endl;
        for (IComponent* child : children) {
            child->showInfo();  // 遍历并显示子部门或员工信息
        }
    }
};

• Department 类是组合节点，可以包含员工（Employee）和子部门（Department）。
• add() 方法用于将员工或子部门添加到部门中。
• showInfo() 方法用于显示部门信息并递归调用子部门和员工的信息。

4. 客户端调用

int main() {
    // 创建员工
    IComponent* employee1 = new Employee("John Doe", "Software Engineer");
    IComponent* employee2 = new Employee("Jane Smith", "Product Manager");

    // 创建部门
    IComponent* department1 = new Department("Engineering");
    IComponent* department2 = new Department("Product");

    // 将员工添加到部门
    dynamic_cast<Department*>(department1)->add(employee1);
    dynamic_cast<Department*>(department2)->add(employee2);

    // 创建公司并添加部门
    Department* company = new Department("TechCorp");
    company->add(department1);
    company->add(department2);

    // 展示信息
    company->showInfo();

    // 清理内存
    delete employee1;
    delete employee2;
    delete department1;
    delete department2;
    delete company;

    return 0;
}

5. 输出结果

Department: TechCorp
Department: Engineering
Employee: John Doe, Position: Software Engineer
Department: Product
Employee: Jane Smith, Position: Product Manager

• 我们创建了一个 TechCorp 公司，它包含两个部门：“Engineering” 和 “Product”。
• 每个部门包含一个员工，Engineering 部门有一个软件工程师，Product 部门有一个产品经理。
• 最后，company->showInfo() 方法会递归地显示公司、部门和员工的完整信息。

组合模式的优缺点

优点：

• 简化客户端代码：客户端可以一致地处理单个对象和组合对象，无需关心它们的具体类型。
• 扩展性好：增加新的组合节点或叶子节点非常容易，只需要扩展 IComponent 接口和实现类。
• 透明化处理：组合模式隐藏了树形结构的复杂性，客户端不需要关心是操作叶子节点还是组合节点。

缺点：

• 管理复杂性：当树形结构很复杂时，组合模式可能会导致管理和维护复杂，尤其是当树的深度很大时。
• 效率问题：对于深度嵌套的树形结构，递归遍历可能会带来性能上的影响。

场景

适用场景：

树形结构：当系统中存在层次化的对象结构时，可以使用组合模式来组织这些对象。例如，文件系统、UI组件、组织结构等。
部分-整体结构：当需要对单个对象和对象集合进行一致的处理时，可以使用组合模式。
需要统一接口管理多层次结构：组合模式适合在管理层次结构时提供一个统一的接口。

编程案例

1.文件系统：在文件系统中，文件和文件夹之间存在“部分-整体”的层次结构。文件夹包含文件或子文件夹，文件夹本身也是一个对象，文件是叶子对象。通过组合模式，客户端可以通过统一接口操作文件和文件夹，而无需关心它们的具体类型。

2.UI组件的管理：在GUI设计中，窗口、面板、按钮等UI组件可以组成树形结构。窗口包含面板，面板包含按钮。使用组合模式，UI的管理和展示可以非常简洁，所有组件通过统一接口进行管理。

3.组织结构：公司和部门的组织结构是典型的“部分-整体”结构。部门下有员工、子部门等，组合模式可以将其简化为一个统一的接口来处理所有层级的对象。

总结

组合模式通过构建树形结构，允许客户端一致地处理单个对象和组合对象。它简化了树形结构的管理，使得对象的处理变得更加直观和方便。组合模式适用于有层次结构的场景，例如文件系统、组织结构、UI组件等，能够有效地将“部分-整体”结构统一化，减少了系统的复杂性和耦合度。