设计模式之组合模式

问题背景

想象我们正在开发一个图形界面应用程序，这个程序允许用户创建和操作不同的几何图形。在这个应用中，用户可以独立地操作如圆形、矩形等基础图形，也可以将这些图形组合起来创建复杂的设计，如设计一个表情符号，其中眼睛是两个小圆，嘴是一个椭圆形。

用户应该能够对这些单独的图形或者整个组合执行相同的操作，比如移动和重绘，而不需要关心它们是单独的对象还是对象的一部分。这个需求引导我们考虑使用组合模式来简化对象的管理和操作。

问题分析

为了满足上述需求，我们可以采用组合模式构建应用程序的核心功能。我们将定义一个抽象的基类Graphic，它将声明所有具体图形和图形组合都应实现的接口，例如move、draw等方法。

具体图形如Circle和Rectangle将是Graphic的子类，实现具体的操作方法。此外，我们还需要一个名为CompositeGraphic的类，它也继承自Graphic，用于存储和管理图形对象的集合，同时实现与单个图形相同的接口。

这种设计允许客户端代码通过统一的接口与单个图形或图形的组合交互，无需区分它们是简单的还是复合的对象。

代码部分

我们首先实现图形的接口和具体的图形类：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 抽象基类，定义图形操作的接口
class Graphic {
public:
    virtual void move(int x, int y) = 0;
    virtual void draw() const = 0;
    virtual ~Graphic() {}
};

// 圆形类，实现具体操作
class Circle : public Graphic {
private:
    int x, y, radius;
public:
    Circle(int x, int y, int radius) : x(x), y(y), radius(radius) {}

    void move(int dx, int dy) override {
        x += dx;
        y += dy;
    }

    void draw() const override {
        cout << "Drawing Circle at (" << x << ", " << y << ") with radius " << radius << endl;
    }
};

// 矩形类，实现具体操作
class Rectangle : public Graphic {
private:
    int x, y, width, height;
public:
    Rectangle(int x, int y, int width, int height)
        : x(x), y(y), width(width), height(height) {}

    void move(int dx, int dy) override {
        x += dx;
        y += dy;
    }

    void draw() const override {
        cout << "Drawing Rectangle at (" << x << ", " << y << ") with width " << width << " and height " << height << endl;
    }
};

接下来，我们将实现复合类CompositeGraphic：

// 复合图形类，可以包含其他图形对象
class CompositeGraphic : public Graphic {
private:
    vector<Graphic*> children;

public:
    // 添加图形到组合
    void add(Graphic* graphic) {
        children.push_back(graphic);
    }

    // 移动组合图形中的所有图形
    void move(int dx, int dy) override {
        for (auto& child : children) {
            child->move(dx, dy);
        }
    }

    // 绘制组合图形中的所有图形
    void draw() const override {
        for (const auto& child : children) {
            child->draw();
        }
    }

    // 析构函数，清理内存
    ~CompositeGraphic() {
        for (auto& child : children) {
            delete child;
        }
        children.clear();
    }
};

这部分代码定义了基本图形和一个可以包含这些图形的复合图形。我们创建了Circle和Rectangle作为具体图形，以及CompositeGraphic`来组合和管理这些图形。

int main() {
    // 创建单个图形
    Graphic* circle1 = new Circle(1, 2, 3);
    Graphic* rectangle1 = new Rectangle(5, 5, 6, 2);

    // 创建图形组合
    CompositeGraphic* composite = new CompositeGraphic();
    composite->add(circle1);
    composite->add(rectangle1);

    // 绘制所有图形
    cout << "Drawing all graphics:" << endl;
    composite->draw();

    // 移动所有图形
    cout << "Moving all graphics:" << endl;
    composite->move(2, 3);
    composite->draw();

    // 清理资源
    delete composite;  // 自动删除子对象

    return 0;
}

代码分析

基类 Graphic的作用：
在我们的组合模式实现中，Graphic 类充当了抽象组件角色。这个类定义了所有具体图形对象和组合图形对象必须实现的接口。通过定义这样一个接口，我们确保了无论是简单的图形还是复杂的图形组合，客户端都可以以相同的方式对它们进行操作，如移动(move)和绘制(draw)。

具体图形类：
Circle 和 Rectangle 类分别实现了 Graphic 的接口。这些类中的 move 方法用于更新图形的位置，而 draw 方法用于在控制台输出图形的位置和其他属性，模拟图形的绘制过程。这些具体类充当了叶子节点，在组合结构中代表没有子对象的图形元素。

复合类 CompositeGraphic：
CompositeGraphic 类实现了复杂图形的组合。它同样继承自 Graphic 类，并且存储了一个图形对象的列表。通过实现相同的 move 和 draw 接口，CompositeGraphic 能够递归地调用其包含的所有图形对象的相应方法，这允许单一或统一的方式操作整个图形组合。此外，其析构函数负责清理所包含的图形对象，防止内存泄漏。

优点：

• 统一接口：客户端代码可以通过同一接口处理单个对象和组合对象，这大大简化了客户端代码的复杂性。
• 灵活性和扩展性：新的图形类型可以轻松添加到系统中，只需确保它们实现了 Graphic 接口。由于 CompositeGraphic 类与具体的图形类解耦，它可以不受影响地继续操作。
• 简化的客户端操作：客户端不需要知道它正在处理的是简单的还是复合的图形对象，这使得执行操作（如移动或绘制）时更加直接和简单。

组合模式的编程要点可以概括为以下几个关键方面：

1. 定义统一接口：创建一个抽象基类或接口（如 Graphic），定义所有组件共有的操作。这些操作包括但不限于移动、绘制等功能。这一接口既适用于单个对象，也适用于对象的组合。

2. 实现具体组件：实现具体的叶节点组件（如 Circle 和 Rectangle），它们是组合结构的基本元素，直接实现在抽象基类中定义的操作。

3. 创建组合类：实现一个组合类（如 CompositeGraphic），它也继承自抽象基类。组合类可以包含其他的叶节点组件或更多的组合类对象，形成一个树状结构。组合类需要在内部管理子组件的列表，并能将接口中定义的请求（如移动和绘制）传递给所有子组件。

4. 管理子组件：组合类应该提供方法来添加和管理子组件。例如，通过方法如 add 将新的子组件加入到组合中。此外，组合类通常需要管理这些子组件的生命周期，确保在组合类被销毁时，所有的子组件也被适当地释放。

5. 透明的组件操作：客户端应该能够一致地对待单个对象和组合对象。即客户端代码通过统一的接口与单个图形或图形的组合交互，而无需关心它们具体是单个对象还是组成的一部分。

6. 递归组合：组合模式允许通过递归方式来组合任意多的对象。这种结构使得整个对象体系呈树形结构，客户端对树的任何一个部分的操作都可以通过组合方式向下传递到每一个叶节点。

7. 资源管理：在C++中，由于组合模式通常涉及动态分配内存（如通过 new 创建子对象），因此组合类需要负责这些对象的资源管理，通常在组合类的析构函数中删除所有子对象，避免内存泄漏。

通过实现组合模式，可以使得客户端在处理单个对象和组合对象时具有一致性，同时简化了客户端与复杂对象集合交互的复杂性。这种模式特别适合于那些可以递归分解为更小部分的问题领域，例如图形编辑器中的图形管理。