组合模式允许我们将对象组合成树形结构来表示部分-整体的层次关系，在C++中实现这种模式时，递归操作是处理树形节点的核心手段，而结合访问控制可以让不同权限的调用方只能操作有权限的节点，提升系统的安全性。
组合模式的基础结构
组合模式通常包含三个角色：抽象组件、叶子节点和组合节点。抽象组件定义了所有节点共有的接口，叶子节点是树形结构的末端节点，组合节点可以包含其他子节点。
首先定义抽象组件Component，声明公共接口和访问权限相关的属性：
#include <iostream>
#include <vector>
#include <string>
#include <memory>
// 访问权限枚举
enum class AccessLevel {
READ_ONLY,
READ_WRITE,
ADMIN
};
// 抽象组件类
class Component {
protected:
std::string name;
AccessLevel accessLevel;
public:
Component(const std::string& n, AccessLevel level) : name(n), accessLevel(level) {}
virtual ~Component() = default;
// 获取节点名称
std::string getName() const {
return name;
}
// 获取访问权限
AccessLevel getAccessLevel() const {
return accessLevel;
}
// 添加子节点，组合节点重写该方法
virtual void add(std::shared_ptr<Component> component) {
throw std::runtime_error("叶子节点不支持添加子节点");
}
// 递归操作接口，由子类实现具体逻辑
virtual void recursiveOperation(AccessLevel callerLevel) = 0;
};
叶子节点与组合节点的实现
叶子节点没有子节点，递归操作仅处理自身；组合节点包含子节点列表，递归操作会遍历所有子节点执行对应逻辑，同时结合调用方的权限判断是否可以执行操作。
叶子节点Leaf的实现如下：
// 叶子节点类
class Leaf : public Component {
public:
Leaf(const std::string& n, AccessLevel level) : Component(n, level) {}
void recursiveOperation(AccessLevel callerLevel) override {
// 判断调用方是否有访问权限
if (callerLevel >= accessLevel) {
std::cout << "叶子节点 [" << name << "] 执行操作，调用方权限: " << static_cast<int>(callerLevel) << std::endl;
} else {
std::cout << "叶子节点 [" << name << "] 访问被拒绝，调用方权限不足" << std::endl;
}
}
};
组合节点Composite的实现如下，包含子节点管理逻辑和递归遍历逻辑：
// 组合节点类
class Composite : public Component {
private:
std::vector<std::shared_ptr<Component>> children;
public:
Composite(const std::string& n, AccessLevel level) : Component(n, level) {}
void add(std::shared_ptr<Component> component) override {
children.push_back(component);
}
void recursiveOperation(AccessLevel callerLevel) override {
// 先判断当前组合节点是否可访问
if (callerLevel >= accessLevel) {
std::cout << "组合节点 [" << name << "] 执行操作，调用方权限: " << static_cast<int>(callerLevel) << std::endl;
// 递归遍历所有子节点
for (auto& child : children) {
child->recursiveOperation(callerLevel);
}
} else {
std::cout << "组合节点 [" << name << "] 访问被拒绝，调用方权限不足" << std::endl;
}
}
};
完整使用示例
下面构建一个简单的树形结构，模拟不同权限调用方执行递归操作的效果：
int main() {
// 创建根节点，管理员权限
auto root = std::make_shared<Composite>("根节点", AccessLevel::ADMIN);
// 创建一级子节点，读写权限
auto child1 = std::make_shared<Composite>("子节点1", AccessLevel::READ_WRITE);
// 创建一级子节点，只读权限
auto child2 = std::make_shared<Composite>("子节点2", AccessLevel::READ_ONLY);
root->add(child1);
root->add(child2);
// 给子节点1添加叶子节点，读写权限
auto leaf1 = std::make_shared<Leaf>("叶子节点1-1", AccessLevel::READ_WRITE);
child1->add(leaf1);
// 给子节点2添加叶子节点，只读权限
auto leaf2 = std::make_shared<Leaf>("叶子节点2-1", AccessLevel::READ_ONLY);
child2->add(leaf2);
// 只读权限调用方执行递归操作
std::cout << "=== 只读权限调用方操作 ===" << std::endl;
root->recursiveOperation(AccessLevel::READ_ONLY);
std::cout << std::endl;
// 读写权限调用方执行递归操作
std::cout << "=== 读写权限调用方操作 ===" << std::endl;
root->recursiveOperation(AccessLevel::READ_WRITE);
std::cout << std::endl;
// 管理员权限调用方执行递归操作
std::cout << "=== 管理员权限调用方操作 ===" << std::endl;
root->recursiveOperation(AccessLevel::ADMIN);
return 0;
}
实现要点说明
- 抽象组件中声明统一的递归操作接口，所有节点都实现该接口，保证客户端可以以一致的方式调用。
- 递归操作的核心是组合节点的遍历逻辑，先处理当前节点再递归处理子节点，实现树形结构的深度优先遍历。
- 访问控制通过权限等级比较实现，调用方的权限等级大于等于节点要求的权限等级时才可以执行操作，否则直接跳过。
- 叶子节点的
add方法抛出异常，避免错误调用，符合组合模式中叶子节点不支持添加子节点的设计。
适用场景
这种结合方式适合需要管理树形结构且存在权限区分的系统，比如文件系统权限管理、组织架构管理、菜单权限控制等场景，既可以统一处理部分与整体的关系，又能保证不同角色只能操作对应权限范围内的节点。