C++设计模式之组合模式详解

简介

组合模式（Composite Pattern）是一种结构型设计模式，旨在将对象组合成树形结构以表示"部分-整体"的层次结构。它使得客户端可以统一处理单个对象和组合对象（即对象的集合），从而简化了复杂结构的处理方式。

设计理念

组合模式通过将对象组织成树形结构，使得客户端能够以相同的方式对待单个对象和对象组合。这种模式的核心思想是：允许客户端以一致的方式处理单个对象和组合对象。

组成部分

Component（组件） ：定义了所有具体组件（叶子和组合）的公共接口。它可以是抽象类或接口，通常包含一些基本的操作方法，如operation()、add()、remove()、getChild()等。
Leaf（叶子） ：实现了Component接口，表示树形结构中的叶子节点，叶子节点不包含子节点。
Composite（组合） ：实现了Component接口，表示树形结构中的非叶子节点（即包含子节点的节点）。它通常有一个集合来存储子组件，并且实现了对这些子组件的操作方法。

UML 类图

cpp 复制代码

              +----------------------+
              |     Component        |
              +----------------------+
              | - operation()        |
              +----------------------+
              | + add(Component*)    |
              | + remove(Component*) |
              | + getChild(int)      |
              +----------------------+
                        / \
                         |
          +-----------------------------+
          |                             |
  +--------------+             +----------------+
  |   Leaf       |             |   Composite     |
  +--------------+             +----------------+
  | - operation()|             | - operation()   |
  |              |             | - add(Component*) |
  |              |             | - remove(Component*) |
  +--------------+             | - getChild(int)   |
                               +----------------+

使用场景

组合模式适用于以下几种情况：

需要表示对象的部分-整体层次结构：例如文件系统、组织结构等，其中文件夹可以包含其他文件夹和文件。
希望客户端忽略组合对象与单个对象的差异：客户端可以通过相同的接口处理叶子节点和组合节点，而无需关心它们的具体实现。

详细实现

以下是一个更详细的C++实现，演示如何使用组合模式来创建一个表示公司结构的系统。

步骤 1：定义组件基类 Component

Component类是所有叶子和组合对象的基类。它声明了一些基本的操作方法。

cpp 复制代码

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

// 抽象基类
class Component {
public:
    virtual ~Component() = default;
    
    virtual void operation() const = 0; // 业务操作
    virtual void add(std::shared_ptr<Component> component) {} // 添加子组件
    virtual void remove(std::shared_ptr<Component> component) {} // 移除子组件
    virtual std::shared_ptr<Component> getChild(int index) const { return nullptr; } // 获取子组件
};

步骤 2：定义叶子类 Leaf

Leaf类实现了Component接口，但不支持添加或移除子组件。

cpp 复制代码

// 叶子节点类
class Leaf : public Component {
private:
    std::string name; // 叶子节点名称

public:
    Leaf(const std::string& name) : name(name) {}

    void operation() const override {
        std::cout << "Leaf " << name << " operation." << std::endl;
    }
};

步骤 3：定义组合类 Composite

Composite类实现了Component接口，支持对子组件的管理和递归操作。

cpp 复制代码

// 组合节点类
class Composite : public Component {
private:
    std::vector<std::shared_ptr<Component>> children; // 存储子组件

public:
    void operation() const override {
        std::cout << "Composite operation." << std::endl;
        for (const auto& child : children) {
            child->operation(); // 递归调用子组件的操作
        }
    }

    void add(std::shared_ptr<Component> component) override {
        children.push_back(component); // 添加子组件
    }

    void remove(std::shared_ptr<Component> component) override {
        children.erase(std::remove(children.begin(), children.end(), component), children.end()); // 移除子组件
    }

    std::shared_ptr<Component> getChild(int index) const override {
        if (index >= 0 && index < children.size()) {
            return children[index]; // 获取子组件
        }
        return nullptr;
    }
};

步骤 4：客户端代码示例

在客户端代码中，我们创建了叶子节点和组合节点，并执行操作。

cpp 复制代码

int main() {
    // 创建叶子节点
    auto leaf1 = std::make_shared<Leaf>("Leaf 1");
    auto leaf2 = std::make_shared<Leaf>("Leaf 2");
    
    // 创建组合节点
    auto composite = std::make_shared<Composite>();
    
    // 添加叶子节点到组合节点中
    composite->add(leaf1);
    composite->add(leaf2);
    
    // 创建更大的组合节点并添加子组合节点和叶子节点
    auto root = std::make_shared<Composite>();
    root->add(composite);
    root->add(std::make_shared<Leaf>("Leaf 3"));
    
    // 执行组合对象的操作
    root->operation();

    return 0;
}

cpp

复制代码

int main() { // 创建叶子节点 auto leaf1 = std::make_shared<Leaf>("Leaf 1"); auto leaf2 = std::make_shared<Leaf>("Leaf 2"); // 创建组合节点 auto composite = std::make_shared<Composite>(); // 添加叶子节点到组合节点中 composite->add(leaf1); composite->add(leaf2); // 创建更大的组合节点并添加子组合节点和叶子节点 auto root = std::make_shared<Composite>(); root->add(composite); root->add(std::make_shared<Leaf>("Leaf 3")); // 执行组合对象的操作 root->operation(); return 0; }

输出结果

cpp 复制代码

Composite operation.
Composite operation.
Leaf Leaf 1 operation.
Leaf Leaf 2 operation.
Leaf Leaf 3 operation.

复制代码

Composite operation. Composite operation. Leaf Leaf 1 operation. Leaf Leaf 2 operation. Leaf Leaf 3 operation.

详细说明

Component类 ：提供了统一的接口，所有的叶子节点和组合节点都继承自这个类。它声明了operation()方法，以及处理子组件的方法add、remove、getChild。这些方法在Leaf类中是无用的，因此在Leaf中没有实现。
Leaf类 ：表示树的叶子节点，不能有子节点。它实现了operation()方法，执行具体的业务逻辑。
Composite类 ：表示树的非叶子节点。它包含一个子组件列表，并实现了add、remove、getChild等方法。operation()方法会递归地调用所有子组件的operation()方法。
客户端代码 ：演示了如何使用组合模式来创建树形结构，并调用其方法。通过Composite类，我们能够轻松地管理子组件，并执行统一的操作。

组合模式的优点和缺点

优点

透明性：客户端可以一致地处理单个对象和组合对象，简化了代码逻辑。
灵活性：能够方便地添加新的组件类型，扩展功能。
简化代码：客户端代码可以减少对组合和叶子节点的区别处理，从而使代码更简洁。

缺点

设计复杂 ：组合模式会增加类的数量，因为每个组合和叶子节点都需要实现Component接口，可能导致系统复杂性增加。
类型安全性降低：组合模式将所有对象的接口抽象化，可能会降低类型安全性，特别是在处理组合的子组件时。

实际应用

文件系统：在文件系统中，目录可以包含其他目录和文件，符合组合模式的设计思路。
图形界面：在图形界面设计中，窗口、按钮、面板等组件可以组成复杂的界面结构，组合模式能够有效地处理这些组件。
组织结构：公司或组织结构中的部门和员工也可以使用组合模式来表示，部门可以包含其他部门或员工。

总结

组合模式通过将对象组织成树形结构，使得客户端能够以一致的方式对待单个对象和对象组合。这种模式在处理复杂的部分-整体结构时非常有效，能够简化代码并提高灵活性。然而，它也可能增加设计复杂度和降低类型安全性。在实际应用中，组合模式广泛用于文件系统、GUI设计、组织结构等场景。

希望这篇文章能够帮助您深入理解组合模式，并在实际开发中灵活应用。

参考文献

《设计模式：可复用面向对象软件的基础》------Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Cplusplus.com
Design Patterns: Elements of Reusable Object-Oriented Software