C++组合模式透明与安全方式对比

2026-04-02 16:50:21 297阅读 0评论

在软件开发中，组合模式是一种结构型设计模式，它允许你将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式使得客户端可以统一地处理单个对象和组合对象。然而，在实现组合模式时，如何平衡透明性和安全性是一个重要的问题。

透明组合模式

透明组合模式是最简单的实现方式，它要求组合对象和叶子对象具有一致的接口。这样，客户端代码可以直接调用这些接口，而不需要关心它们的具体类型。

实现示例

#include <iostream>
#include <vector>

class Component {
public:
    virtual ~Component() = default;
    virtual void operation() const = 0;
};

class Leaf : public Component {
public:
    void operation() const override {
        std::cout << "Leaf operation" << std::endl;
    }
};

class Composite : public Component {
private:
    std::vector<std::unique_ptr<Component>> children;

public:
    void add(std::unique_ptr<Component> child) {
        children.push_back(std::move(child));
    }

    void remove(Component* child) {
        auto it = std::find_if(children.begin(), children.end(),
                               [child](const std::unique_ptr<Component>& c) { return c.get() == child; });
        if (it != children.end()) {
            children.erase(it);
        }
    }

    void operation() const override {
        for (const auto& child : children) {
            child->operation();
        }
    }
};

优点

一致性：组合对象和叶子对象具有相同的接口，简化了客户端代码。
灵活性：客户端可以统一处理单个对象和组合对象。

缺点

性能问题：由于需要遍历所有子节点，操作可能会比较耗时。
增加复杂性：需要维护一个复杂的树形结构，增加了代码的复杂度。

安全组合模式

安全组合模式通过引入访问者模式或迭代器模式来提高组合模式的安全性。这种方式避免了客户端直接操作组合对象的内部结构，从而提高了系统的安全性。

实现示例

#include <iostream>
#include <vector>

class Component {
public:
    virtual ~Component() = default;
    virtual void accept(class Visitor* visitor) = 0;
    virtual void operation() const = 0;
};

class Leaf : public Component {
public:
    void accept(Visitor* visitor) override {
        visitor->visit(this);
    }

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

class Composite : public Component {
private:
    std::vector<std::unique_ptr<Component>> children;

public:
    void add(std::unique_ptr<Component> child) {
        children.push_back(std::move(child));
    }

    void remove(Component* child) {
        auto it = std::find_if(children.begin(), children.end(),
                               [child](const std::unique_ptr<Component>& c) { return c.get() == child; });
        if (it != children.end()) {
            children.erase(it);
        }
    }

    void accept(Visitor* visitor) override {
        for (const auto& child : children) {
            child->accept(visitor);
        }
    }

    void operation() const override {
        for (const auto& child : children) {
            child->operation();
        }
    }
};

class Visitor {
public:
    virtual ~Visitor() = default;
    virtual void visit(const Component* component) = 0;
};

class ConcreteVisitor : public Visitor {
public:
    void visit(const Component* component) override {
        std::cout << "ConcreteVisitor visits ";
        component->operation();
    }
};