C++组合模式：现代实现与性能优化实践

1. 组合模式基础回顾与核心痛点

组合模式（Composite Pattern）是面向对象设计中最优雅的模式之一，它通过树形结构组织对象，使得单个对象和组合对象能够被统一处理。在C++中实现组合模式时，我们通常会遇到几个典型场景：

• 需要表示部分-整体层次结构（如文件系统）
• 希望客户端忽略组合对象与单个对象的不同
• 需要对树形结构中的所有节点执行统一操作

传统实现方式如示例代码所示，包含三个关键角色：

cpp复制class Component {
    // 声明所有子类共有的接口
    virtual void operation() = 0;
};

class Leaf : public Component {
    // 叶子节点实现
    void operation() override { /*...*/ }
};

class Composite : public Component {
    // 容器节点实现，包含子组件集合
    std::vector<Component*> children;
    void operation() override {
        for(auto child : children) {
            child->operation();  // 递归调用
        }
    }
};

这种经典实现存在几个明显痛点：

1. 类型安全缺失：add()/remove()等方法在叶子节点中需要空实现或抛出异常
2. 内存管理复杂：原始指针的使用容易导致内存泄漏
3. 遍历效率低下：对大型树结构进行频繁遍历时性能不佳
4. 扩展性受限：新增节点类型时需要修改多处代码

2. 现代C++下的安全实现变体

2.1 智能指针与类型安全改进

使用std::unique_ptr和std::shared_ptr可以显著改善内存管理问题。我们可以重构基础类设计：

cpp复制class Component {
public:
    virtual ~Component() = default;
    virtual void display() const = 0;
    
    // 仅Composite需要的方法设为protected
protected:
    virtual void add(std::unique_ptr<Component>) {
        throw std::logic_error("Unsupported operation");
    }
    virtual void remove(Component*) {
        throw std::logic_error("Unsupported operation");
    }
};

叶子节点的实现变得简洁：

cpp复制class Leaf : public Component {
    std::string name;
public:
    explicit Leaf(std::string n) : name(std::move(n)) {}
    void display() const override {
        std::cout << "Leaf: " << name << '\n';
    }
    // 不再需要实现add/remove
};

2.2 基于CRTP的静态多态变体

Curiously Recurring Template Pattern (CRTP) 可以在编译期确定类型关系：

cpp复制template <typename Derived>
class ComponentBase {
public:
    void display() const {
        static_cast<const Derived*>(this)->displayImpl();
    }
};

class Leaf : public ComponentBase<Leaf> {
    void displayImpl() const { /*...*/ }
};

template <typename T>
class Composite : public ComponentBase<Composite<T>> {
    std::vector<T> children;
    void displayImpl() const {
        for(const auto& child : children) {
            child.display();
        }
    }
};

这种变体的优势：

• 完全消除运行时虚函数开销
• 编译期类型检查更严格
• 可以针对特定类型优化容器实现

3. 性能优化变体设计

3.1 扁平化存储与索引查找

对于大规模静态结构，可以使用连续内存存储：

cpp复制struct Tree {
    std::vector<Node> nodes;
    std::vector<Range> childrenRanges; // 记录子节点范围
};

class FlatComposite {
    Tree& tree;
    size_t myIndex;
    
    void display() const {
        const auto& range = tree.childrenRanges[myIndex];
        for(size_t i = range.start; i < range.end; ++i) {
            tree.nodes[i].display();
        }
    }
};

性能对比（百万节点测试）：

3.2 缓存优化实现

为频繁访问的节点添加缓存：

cpp复制class CachedComposite : public Component {
    mutable std::optional<std::string> cachedDisplay;
    std::vector<std::unique_ptr<Component>> children;
    
    void invalidateCache() {
        cachedDisplay.reset();
        // 如果需要，向上传播失效通知
    }
    
public:
    void add(std::unique_ptr<Component> c) override {
        children.push_back(std::move(c));
        invalidateCache();
    }
    
    void display() const override {
        if(!cachedDisplay) {
            std::ostringstream oss;
            for(const auto& child : children) {
                child->display(oss);
            }
            cachedDisplay = oss.str();
        }
        std::cout << *cachedDisplay;
    }
};

4. 业务场景特化变体

4.1 不可变组合模式

适用于配置类场景，使用建造者模式创建：

cpp复制class ImmutableComponent {
    std::vector<ImmutableComponent> children;
    std::string name;
    
    // 私有构造函数
    ImmutableComponent(std::string n, std::vector<ImmutableComponent> c)
        : name(std::move(n)), children(std::move(c)) {}
        
public:
    class Builder {
        std::string name;
        std::vector<ImmutableComponent> children;
    public:
        Builder& addChild(ImmutableComponent c) {
            children.push_back(std::move(c));
            return *this;
        }
        
        ImmutableComponent build() {
            return ImmutableComponent{std::move(name), std::move(children)};
        }
    };
    
    void display() const {
        for(const auto& child : children) {
            child.display();
        }
    }
};

4.2 命令执行组合

将操作抽象为命令对象：

cpp复制class CommandComponent {
public:
    virtual void execute(const Command& cmd) = 0;
};

class CommandComposite : public CommandComponent {
    std::vector<std::unique_ptr<CommandComponent>> children;
    
    void execute(const Command& cmd) override {
        if(cmd.shouldPropagate()) {
            for(auto& child : children) {
                child->execute(cmd);
            }
        }
        cmd.executeOn(*this);
    }
};

5. 实际工程中的经验教训

在大型C++项目中应用组合模式时，有几个关键注意事项：

1. 循环引用问题：

   cpp复制// 错误示例：父节点和子节点相互持有shared_ptr会导致内存泄漏
   class Node {
       std::vector<std::shared_ptr<Node>> children;
       std::shared_ptr<Node> parent;  // 危险！
   };
   
   // 正确做法：子节点使用weak_ptr引用父节点
   class SafeNode {
       std::vector<std::shared_ptr<SafeNode>> children;
       std::weak_ptr<SafeNode> parent;
   };
   

2. 迭代器失效问题：
   在遍历过程中修改树结构会导致未定义行为。推荐两种解决方案：

   • 使用标记-清除方式延迟删除
   • 采用快照迭代器模式

3. 多线程安全：

   cpp复制class ThreadSafeComposite {
       mutable std::mutex mtx;
       std::vector<std::unique_ptr<Component>> children;
       
   public:
       void add(std::unique_ptr<Component> c) {
           std::lock_guard lock(mtx);
           children.push_back(std::move(c));
       }
       
       void display() const {
           std::vector<std::unique_ptr<Component>> localCopy;
           {
               std::lock_guard lock(mtx);
               localCopy = children;  // 需要实现深拷贝
           }
           for(const auto& child : localCopy) {
               child->display();
           }
       }
   };
   

4. 性能监控技巧：
   可以通过装饰器模式添加性能统计：

   cpp复制class ProfiledComponent : public Component {
       Component& wrapped;
       mutable std::atomic<size_t> callCount{0};
   public:
       void display() const override {
           auto start = std::chrono::high_resolution_clock::now();
           wrapped.display();
           auto end = std::chrono::high_resolution_clock::now();
           // 记录统计信息...
           callCount++;
       }
   };
   

在编译器优化方面，对于深度较大的组合结构，建议：

• 使用-fno-rtti减少类型信息开销
• 对叶子节点使用final关键字
• 考虑使用内存池分配器