组合模式（Composite Pattern）

定义

组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构，并且能像使用单独对象一样使用组合对象。组合模式让客户端代码对单个对象和复合对象的使用具有一致性。

在组合模式中，我们定义以下几个角色：

Component：这是一个抽象组件接口，它定义了所有组件共有的行为。这些行为包括添加和删除子组件、显示子组件等。
Leaf：这是具体组件，也就是叶子节点，它实现了组件接口，但没有子组件。
Composite：这也是具体组件，但它充当容器角色，它持有一组子组件，并实现了组件接口。Composite 负责在其内部实现子组件的递归组合。

示例

下面是一个C++中使用组合模式的示例，我们创建一个简单的图形系统，其中包含圆形、矩形和组合图形（可以包含其他图形）：

cpp 复制代码

#include <iostream>  
#include <vector>  
  
// 组件接口  
class Shape {  
public:  
    virtual void draw() = 0;  
    virtual void add(Shape* shape) = 0;  
    virtual void remove(Shape* shape) = 0;  
    virtual std::vector<Shape*> getChildren() = 0;  
};  
  
// 叶子节点：圆形  
class Circle : public Shape {  
private:  
    int radius;  
  
public:  
    Circle(int radius) : radius(radius) {}  
  
    void draw() override {  
        std::cout << "Drawing Circle with radius: " << radius << std::endl;  
    }  
  
    void add(Shape* shape) override {  
        // 圆形不能添加子组件  
    }  
  
    void remove(Shape* shape) override {  
        // 圆形不能删除子组件  
    }  
  
    std::vector<Shape*> getChildren() override {  
        return {}; // 圆形没有子组件  
    }  
};  
  
// 叶子节点：矩形  
class Rectangle : public Shape {  
private:  
    int width, height;  
  
public:  
    Rectangle(int width, int height) : width(width), height(height) {}  
  
    void draw() override {  
        std::cout << "Drawing Rectangle with width: " << width << " and height: " << height << std::endl;  
    }  
  
    void add(Shape* shape) override {  
        // 矩形不能添加子组件  
    }  
  
    void remove(Shape* shape) override {  
        // 矩形不能删除子组件  
    }  
  
    std::vector<Shape*> getChildren() override {  
        return {}; // 矩形没有子组件  
    }  
};  
  
// 容器节点：组合图形  
class CompositeShape : public Shape {  
private:  
    std::vector<Shape*> children;  
  
public:  
    void draw() override {  
        std::cout << "Drawing CompositeShape:" << std::endl;  
        for (Shape* child : children) {  
            child->draw();  
        }  
    }  
  
    void add(Shape* shape) override {  
        children.push_back(shape);  
    }  
  
    void remove(Shape* shape) override {  
        auto it = std::find(children.begin(), children.end(), shape);  
        if (it != children.end()) {  
            children.erase(it);  
        }  
    }  
  
    std::vector<Shape*> getChildren() override {  
        return children;  
    }  
};  
  
int main() {  
    // 创建组合图形  
    CompositeShape composite;  
  
    // 添加子组件  
    composite.add(new Circle(5));  
    composite.add(new Rectangle(10, 20));  
  
    // 创建另一个组合图形，并添加到之前的组合图形中  
    CompositeShape anotherComposite;  
    anotherComposite.add(new Circle(10));  
    anotherComposite.add(new Rectangle(5, 15));  
    composite.add(&anotherComposite); // 注意这里传递的是指针  
  
    // 绘制组合图形  
    composite.draw();  
  
    // 清理资源（在实际应用中，你可能需要更复杂的内存管理策略）  
    for (Shape* child : composite.getChildren()) {  
        delete child;  
    }  
  
    return 0;  
}

在这个示例中，Shape 是一个抽象组件接口，它定义了所有组件共有的行为。Circle 和 Rectangle 是具体组件（叶子节点），它们实现了 Shape 接口但没有子组件。CompositeShape 是容器组件，它持有一组子组件，并实现了 Shape 接口。

在组合模式示例中，CompositeShape 类扮演着组合对象的角色，它管理着一组子组件，并提供了添加、删除和绘制子组件的方法。由于 CompositeShape 也实现了 Shape 接口，它可以在其他组合对象中被当作一个普通的组件来使用，从而实现了对象组合的一致性。

组合模式的主要优点有：

一致性：客户端代码可以以一致的方式来处理单个对象和组合对象，无需关心对象是否是复合的。
扩展性：你可以方便地添加新的组件类型，因为系统是基于接口而不是具体类构建的。
灵活性：你可以很容易地组合和分解对象，因为组件之间的层次结构是动态的。
封装性：组合模式允许你将一些对象组合成一个树形结构来表现"部分-整体"的层次结构，并且能像使用单个对象一样使用组合对象。

然而，组合模式也有一些潜在的缺点：

复杂性：组合模式可能会增加系统的复杂性，特别是当组合对象嵌套层次很深时。
内存使用：如果组合对象包含大量子组件，可能会占用较多的内存。
性能开销：在遍历组合对象以执行某些操作时，可能会产生额外的性能开销。

在实际应用中，组合模式常用于实现如文件/目录结构、UI组件树、编译器中的语法树等场景，其中整体和部分可以以同样的方式被对待。

回到示例代码，在 main 函数中，我们创建了一个 CompositeShape 对象 composite，并向其添加了几个子组件，包括 Circle 和 Rectangle 对象，以及另一个 CompositeShape 对象 anotherComposite。然后我们调用 draw 方法来绘制整个组合对象。在绘制过程中，CompositeShape 会递归地调用其所有子组件的 draw 方法，从而实现了组合对象的绘制。

最后，我们需要注意资源管理问题。在这个示例中，我们手动删除了所有动态分配的对象，以避免内存泄漏。在实际应用中，你可能需要采取更复杂的内存管理策略，例如使用智能指针（如 std::shared_ptr 或 std::unique_ptr）来自动管理对象的生命周期。