C++设计模式之组合模式中如何实现同一层部件的有序性
在组合模式中，为了实现同一层上部件的有序性，可以采取以下几种设计方法：
1. 使用有序集合
使用有序集合（如 std::list、std::vector 或其他有序容器）来存储和管理子部件。这种方法可以确保子部件按照特定顺序排列，并且可以通过索引访问。
示例代码：
#include <vector>
#include <iostream>
class Component {
public:
virtual void operation() = 0;
virtual ~Component() {}
};
class Leaf : public Component {
public:
void operation() override {
std::cout << "Leaf operation" << std::endl;
}
};
class Composite : public Component {
public:
void operation() override {
for (auto& component : components) {
component->operation();
}
}
void add(Component* component) {
components.push_back(component);
}
void remove(Component* component) {
components.erase(std::remove(components.begin(), components.end(), component), components.end());
}
private:
std::vector<Component*> components;
};
int main() {
Composite* root = new Composite();
root->add(new Leaf());
root->add(new Leaf());
root->add(new Leaf());
root->operation(); // 输出 "Leaf operation" 三次
delete root;
return 0;
}
在这个示例中，Composite 类使用 std::vector 来存储子部件，确保它们按添加顺序排列。
2. 使用索引管理
在添加子部件时，可以指定一个索引位置，从而控制子部件的排列顺序。
示例代码：
#include <vector>
#include <iostream>
class Component {
public:
virtual void operation() = 0;
virtual ~Component() {}
};
class Leaf : public Component {
public:
void operation() override {
std::cout << "Leaf operation" << std::endl;
}
};
class Composite : public Component {
public:
void operation() override {
for (auto& component : components) {
component->operation();
}
}
void add(Component* component, int index) {
if (index < 0 || index > components.size()) {
index = components.size();
}
components.insert(components.begin() + index, component);
}
void remove(Component* component) {
components.erase(std::remove(components.begin(), components.end(), component), components.end());
}
private:
std::vector<Component*> components;
};
int main() {
Composite* root = new Composite();
root->add(new Leaf(), 0); // 插入到位置 0
root->add(new Leaf(), 1); // 插入到位置 1
root->add(new Leaf(), 0); // 插入到位置 0，原来的部件后移
root->operation(); // 输出 "Leaf operation" 三次，顺序为新插入的第一个，然后是原来的第一个，最后是原来的第二个
delete root;
return 0;
}
在这个示例中，add 方法允许你指定插入子部件的索引位置，从而控制子部件的排列顺序。
3. 使用排序标准
如果你需要更复杂的排序逻辑（例如按某些属性排序），可以在添加子部件后对集合进行排序。
示例代码：
#include <vector>
#include <algorithm>
#include <iostream>
class Component {
public:
virtual void operation() = 0;
virtual ~Component() {}
virtual int getPriority() const = 0; // 排序标准
};
class Leaf : public Component {
public:
Leaf(int priority) : priority(priority) {}
void operation() override {
std::cout << "Leaf operation with priority " << priority << std::endl;
}
int getPriority() const override {
return priority;
}
private:
int priority;
};
class Composite : public Component {
public:
void operation() override {
std::sort(components.begin(), components.end(), [](Component* a, Component* b) {
return a->getPriority() < b->getPriority();
});
for (auto& component : components) {
component->operation();
}
}
void add(Component* component) {
components.push_back(component);
}
void remove(Component* component) {
components.erase(std::remove(components.begin(), components.end(), component), components.end());
}
int getPriority() const override {
return 0; // 组合节点的优先级
}
private:
std::vector<Component*> components;
};
int main() {
Composite* root = new Composite();
root->add(new Leaf(3));
root->add(new Leaf(1));
root->add(new Leaf(2));
root->operation(); // 输出 "Leaf operation with priority 1", "Leaf operation with priority 2", "Leaf operation with priority 3"
delete root;
return 0;
}
在这个示例中，Leaf 类有一个 priority 属性，Composite 类在执行操作时会根据优先级对子部件进行排序，从而实现有序性。
总结
通过使用有序集合、索引管理或排序标准，你可以在组合模式中实现同一层上部件的有序性。这些方法可以根据具体需求灵活选择，以满足不同的排序和组织要求
原文地址：https://blog.csdn.net/joshua0137/article/details/144067517
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！