组合模式的核心概念
组合模式的核心思想是将单个对象和组合对象统一对待，让客户端可以一致地处理树形结构中的所有节点。在C++中实现该模式，通常需要定义三个核心角色：抽象组件、叶子节点、组合节点。
角色职责划分
- 抽象组件：定义所有节点共有的操作接口，既可以包含叶子节点支持的操作，也可以包含组合节点支持的操作，比如添加子节点、删除子节点等。
- 叶子节点：表示树形结构中的最底层节点，没有子节点，实现抽象组件中定义的通用操作，对于不支持的操作可以抛出对应异常或者空实现。
- 组合节点：表示树形结构中的中间节点，包含子节点集合，实现抽象组件的所有接口，操作子节点时需要递归处理所有子节点。
C++实现组合模式处理树形结构
抽象组件定义
首先定义抽象组件类，声明所有节点共有的操作方法：
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
// 抽象组件类
class Component {
public:
virtual ~Component() = default;
// 公共操作：显示节点信息
virtual void display(int depth) = 0;
// 组合节点相关操作，默认实现抛出异常
virtual void add(Component* component) {
throw std::runtime_error("当前节点不支持添加子节点操作");
}
virtual void remove(Component* component) {
throw std::runtime_error("当前节点不支持删除子节点操作");
}
virtual Component* getChild(int index) {
throw std::runtime_error("当前节点不支持获取子节点操作");
}
protected:
std::string name; // 节点名称
Component(std::string n) : name(n) {}
};
叶子节点实现
叶子节点继承抽象组件，实现display方法，对于添加、删除子节点的操作直接抛出异常：
// 叶子节点类
class Leaf : public Component {
public:
Leaf(std::string n) : Component(n) {}
void display(int depth) override {
// 根据深度缩进显示节点名称
for (int i = 0; i < depth; ++i) {
std::cout << "-";
}
std::cout << "叶子节点: " << name << std::endl;
}
};
组合节点实现
组合节点需要维护子节点集合，实现所有抽象组件的接口，操作子节点时递归处理：
// 组合节点类
class Composite : public Component {
public:
Composite(std::string n) : Component(n) {}
void display(int depth) override {
// 显示当前节点
for (int i = 0; i < depth; ++i) {
std::cout << "-";
}
std::cout << "组合节点: " << name << std::endl;
// 递归显示所有子节点
for (auto child : children) {
child->display(depth + 2);
}
}
void add(Component* component) override {
children.push_back(component);
}
void remove(Component* component) override {
for (auto it = children.begin(); it != children.end(); ++it) {
if (*it == component) {
children.erase(it);
return;
}
}
}
Component* getChild(int index) override {
if (index >= 0 && index < children.size()) {
return children[index];
}
return nullptr;
}
private:
std::vector<Component*> children; // 子节点集合
};
组合模式使用示例
下面演示如何构建树形结构并执行统一操作：
int main() {
// 创建根节点
Composite* root = new Composite("根节点");
// 创建叶子节点并添加到根节点
Leaf* leaf1 = new Leaf("叶子1");
Leaf* leaf2 = new Leaf("叶子2");
root->add(leaf1);
root->add(leaf2);
// 创建二级组合节点
Composite* subComposite = new Composite("二级组合节点");
Leaf* leaf3 = new Leaf("叶子3");
subComposite->add(leaf3);
// 将二级组合节点添加到根节点
root->add(subComposite);
// 统一遍历所有节点
std::cout << "树形结构遍历结果：" << std::endl;
root->display(0);
// 测试删除操作
root->remove(leaf1);
std::cout << "n删除叶子1后遍历结果：" << std::endl;
root->display(0);
// 释放内存
delete leaf1;
delete leaf2;
delete leaf3;
delete subComposite;
delete root;
return 0;
}
注意事项
使用组合模式时需要注意几个问题：首先是内存管理，示例中使用了裸指针，实际项目中可以结合智能指针避免内存泄漏；其次是抽象组件接口的设计，如果叶子节点和组合节点的操作差异过大，可能会导致叶子节点实现很多无意义的空方法，此时可以考虑将接口拆分，根据实际场景调整设计。
组合模式的优势在于让客户端不需要区分当前操作的是单个对象还是组合对象，统一调用接口即可，大幅降低了客户端代码的复杂度，非常适合文件目录、组织架构、UI组件树等树形结构的场景。