C++组合模式与递归操作结合实现

组合模式通过统一接口处理树形结构中的个体与容器，结合递归实现自然遍历。核心为抽象组件类定义操作与子节点管理，叶子节点仅实现操作，容器节点维护子组件并递归调用其方法。示例中根节点调用operation后逐层展开，体现深度优先遍历。还可扩展查找、统计等递归功能，如findByName递归搜索目标节点。优势在于接口统一、可扩展性强、逻辑清晰，配合智能指针保障内存安全，适用于文件系统、UI树等场景。

在C++中，组合模式（Composite Pattern）常用于处理树形结构，将单个对象与对象组合以统一方式对待。当它与递归操作结合时，能够自然地遍历和操作整个层级结构，特别适合如文件系统、UI控件树、组织结构等场景。

组合模式的基本结构

组合模式的核心是定义一个抽象组件类，包含个体（Leaf）和容器（Composite）的共同接口。容器可以包含多个子组件，并提供添加、删除和访问子节点的方法。

以下是一个简化实现：

#include 
#include 
#include 
// 抽象组件类
class Component {
public:
virtual ~Component() = default;
virtual void operation() const = 0;
virtual void add(std::shared_ptr child) {
throw std::runtime_error("Not supported.");
}
virtual void remove(const Component* child) {
throw std::runtime_error("Not supported.");
}
virtual const std::vector>& getChildren() const {
static std::vector> empty;
return empty;
}
};
// 叶子节点
class Leaf : public Component {
std::string name;
public:
explicit Leaf(const std::string& n) : name(n) {}
void operation() const override {
std::cout << "Leaf " << name << " operation.\n";
}
};
// 容器节点
class Composite : public Component {
std::string name;
std::vector> children;
public:
explicit Composite(const std::string& n) : name(n) {}
void operation() const override {
    std::cout zuojiankuohaophpcnzuojiankuohaophpcn "Composite " zuojiankuohaophpcnzuojiankuohaophpcn name zuojiankuohaophpcnzuojiankuohaophpcn " operation:\n";
    for (const auto& child : children) {
        child-youjiankuohaophpcnoperation();  // 递归调用
    }
}

void add(std::shared_ptrzuojiankuohaophpcnComponentyoujiankuohaophpcn child) override {
    children.push_back(child);
}

void remove(const Component* target) override {
    children.erase(
        std::remove_if(children.begin(), children.end(),
            [target](const std::shared_ptrzuojiankuohaophpcnComponentyoujiankuohaophpcn& ptr) {
                return ptr.get() == target;
            }),
        children.end());
}

const std::vectorzuojiankuohaophpcnstd::shared_ptrzuojiankuohaophpcnComponentyoujiankuohaophpcnyoujiankuohaophpcn& getChildren() const override {
    return children;
}
};
立即学习“C++免费学习笔记（深入）”；
递归操作的自然融合
组合模式中，operation() 方法在容器中自动递归调用其子节点的 operation()，形成深度优先遍历。这种设计使得客户端无需关心当前对象是叶子还是复合体，统一调用即可触发整棵树的操作。
示例使用：

							

								
								

									迷你天猫商城
									
迷你天猫商城是一个基于Spring Boot的综合性B2C电商平台，需求设计主要参考天猫商城的购物流程：用户从注册开始，到完成登录，浏览商品，加入购物车，进行下单，确认收货，评价等一系列操作。 作为迷你天猫商城的核心组成部分之一，天猫数据管理后台包含商品管理，订单管理，类别管理，用户管理和交易额统计等模块，实现了对整个商城的一站式管理和维护。所有页面均兼容IE10及以上现代浏览器。部署方式1、项目
								
								下载 
							
						
int main() {
    auto root = std::make_shared("Root");
    auto branch1 = std::make_shared("Branch1");
    auto branch2 = std::make_shared("Branch2");
auto leaf1 = std::make_sharedzuojiankuohaophpcnLeafyoujiankuohaophpcn("Leaf1");
auto leaf2 = std::make_sharedzuojiankuohaophpcnLeafyoujiankuohaophpcn("Leaf2");
auto leaf3 = std::make_sharedzuojiankuohaophpcnLeafyoujiankuohaophpcn("Leaf3");

branch1-youjiankuohaophpcnadd(leaf1);
branch1-youjiankuohaophpcnadd(leaf2);
branch2-youjiankuohaophpcnadd(leaf3);

root-youjiankuohaophpcnadd(branch1);
root-youjiankuohaophpcnadd(branch2);

root-youjiankuohaophpcnoperation();  // 递归执行整个结构
return 0;
}
输出结果会逐层展开每个节点的操作，体现递归遍历过程。
扩展：支持其他递归操作
除了 operation()，还可以添加如查找、统计、序列化等递归方法。例如实现一个搜索功能：
bool findByName(const Component* comp, const std::string& target) {
    if (auto leaf = dynamic_cast(comp)) {
        return leaf->getName() == target;  // 需为Leaf添加getName()
    }
    if (auto composite = dynamic_cast(comp)) {
        for (const auto& child : composite->getChildren()) {
            if (findByName(child.get(), target)) {
                return true;
            }
        }
    }
    return false;
}
这个函数利用递归深入每一层，直到找到匹配的叶子节点。
关键设计优势


统一接口：客户端对叶子和容器调用相同方法，逻辑更简洁。

可扩展性：新增组件类型不影响现有代码。

递归天然适配：树形结构配合递归，代码清晰且易于维护。

基本上就这些。组合模式搭配递归，让C++中处理层次化数据变得直观高效，不复杂但容易忽略细节，比如异常安全和内存管理，建议使用智能指针避免泄漏。