组合模式是一种结构型设计模式，它允许你将对象组合成树形结构来表现“部分-整体”的层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。
组合模式的核心思想是：将单个对象和组合对象放在一个统一的结构中，从而使得客户端能够以一致的方式处理它们。在组合模式中，客户端只需要面向抽象构件编程，而不必关心具体的叶子节点或容器节点的实现细节。
对象类型
在组合模式中，有两种类型的对象：组合对象和叶子对象。
- 组合对象包含一个或多个叶子对象，同时也可以包含其他组合对象，形成一个树形结构。
- 叶子对象是最基本的对象，它们不包含其他对象。
抽象构件（Component）：定义组合中对象的通用接口，可以是抽象类或接口。
叶子构件（Leaf）：表示组合中的叶子节点对象，没有子节点。
容器构件（Composite）：表示组合中的容器节点对象，有子节点，可以包含叶子节点和其他容器节点。
要素：
- 抽象构件(Component)角色：定义组合中的对象的通用接口，可以是抽象类或接口；抽象类或接口定义了叶子节点和组合节点的公共接口、默认的行为；管理子对象的接口，规定了需要实现的操作方法，如添加、删除、获取子节点等。
- 叶子构件(Leaf)角色：组合中的叶子节点对象，组合模式中最小的单元，不包含其他对象。通常只需要重写抽象构件中的基本操作方法即可。
- 组合构件(Composite)角色：组合中的中间节点对象，它实现了抽象构件接口中的所有方法，并在其中实现对子对象的管理，子对象可以是叶子对象或其他组合对象。
- 客户端(Client)角色：通过抽象构件接口操作组合中的对象。可以通过组合构件来访问和操作整个对象树。
Component 定义了接口，但是并不提供默认的实现，它不能直接实现对子节点的增加、删除操作。反而它将这些操作委托给具体的组件，即 Composite 类。
Composite 类需要实现 Component 接口，并且维护一个子组件列表。它可以递归地向下遍历子组件列表，执行一些操作，例如添加、删除、查找等。
特点有：
- 将对象组成树形结构，实现父子关系，使得客户端可以一致性地处理单个对象和对象的组合。
- 可以使用递归算法遍历整个树形结构，简化了客户端的代码。
- 可以灵活地增加或删除组合对象，对客户端代码的影响较小。
- 可以实现“开闭原则”，即对扩展开放，对修改关闭，通过添加新的组合对象来扩展功能，而无需修改现有代码。
- 可以使得系统具有更好的可维护性和可扩展性。
优点包括：
- 简化客户端代码：客户端可以以相同的方式处理单个对象和对象组合，这简化了客户端代码，使其更易于阅读和维护。
- 提高可扩展性：组合模式使得添加新类型的对象变得容易，只需创建一个新的子类即可，从而提高了可扩展性。
- 增加灵活性：组合模式允许动态地添加或删除对象，从而增加了灵活性。
- 组合模式使得我们可以递归地遍历树形结构中的每个元素，而不必关心它是叶子节点还是组合节点。
- 组合模式使得我们可以向树形结构中添加和删除元素，而不必修改客户端代码。
缺点包括：
- 在某些情况下，组合模式可能会使设计过于抽象化。这可能会导致代码变得更加难以理解和维护。
- 可能降低性能：使用递归算法遍历对象树可能会降低性能。在新增或删除节点时可能会导致性能问题，因为它需要递归遍历整个树形结构。
- 增加复杂性：组合模式增加了对象之间的关系，从而增加了复杂性。使用递归算法来遍历树形结构。
应用场景包括：
- 表示具有层次结构的对象，例如组织机构、文件系统等。
- 处理具有相似操作的单个对象和对象组合，例如图形界面中的控件。
- 描述复杂的配置选项，例如系统的配置文件。
代码实现
#include <iostream>
#include <vector>
class Component {
public:
virtual void operation() = 0;
virtual void add(Component *component) {}
virtual void remove(Component *component) {}
};
class Leaf : public Component {
public:
void operation() override {
std::cout << "Leaf operation" << std::endl;
}
};
class Composite : public Component {
public:
void operation() override {
std::cout << "Composite operation" << std::endl;
for (Component *component : components_) {
component->operation();
}
}
void add(Component *component) override {
components_.push_back(component);
}
void remove(Component *component) override {
// Find and remove the component
for (auto it = components_.begin(); it != components_.end(); ++it) {
if (*it == component) {
components_.erase(it);
break;
}
}
}
private:
std::vector<Component *> components_;
};
int main() {
// Create the composite structure
Component *root = new Composite();
Component *branch1 = new Composite();
Component *branch2 = new Composite();
Component *leaf1 = new Leaf();
Component *leaf2 = new Leaf();
Component *leaf3 = new Leaf();
Component *leaf4 = new Leaf();
// Build the tree
root->add(branch1);
root->add(branch2);
branch1->add(leaf1);
branch1->add(leaf2);
branch2->add(leaf3);
branch2->add(leaf4);
// Execute the operation
root->operation();
// Clean up
delete root;
delete branch1;
delete branch2;
delete leaf1;
delete leaf2;
delete leaf3;
delete leaf4;
return 0;
}
分类
-
透明式组合模式（Transparent Composite Pattern）：透明式组合模式中，抽象构件(Component)中声明了所有用于管理成员对象的方法，包括添加(add)、删除(remove)、获取子节点(getChild)等方法。这样做的好处是所有节点都有一致的接口，客户端可以统一处理所有节点，但是可能会出现一些不需要的方法，例如在叶子节点中实现添加、删除等方法。
-
安全式组合模式（Safe Composite Pattern）：安全式组合模式中，抽象构件(Component)中不声明任何用于管理成员对象的方法，而是在叶子节点和组合节点中分别声明。这样做的好处是可以避免一些不需要的方法，但是客户端需要针对叶子节点和组合节点分别处理。
透明式组合模式
#include <iostream>
#include <vector>
using namespace std;
class Component {
public:
virtual void add(Component* c) {}
virtual void remove(Component* c) {}
virtual void operation() = 0;
};
class Leaf : public Component {
public:
void operation() override {
cout << "Leaf operation" << endl;
}
};
class Composite : public Component {
public:
void add(Component* c) override {
children.push_back(c);
}
void remove(Component* c) override {
for (auto it = children.begin(); it != children.end(); it++) {
if (*it == c) {
children.erase(it);
break;
}
}
}
void operation() override {
cout << "Composite operation" << endl;
for (auto child : children) {
child->operation();
}
}
private:
vector<Component*> children;
};
int main() {
Component* root = new Composite();
Component* child1 = new Composite();
Component* child2 = new Leaf();
Component* child3 = new Leaf();
root->add(child1);
root->add(child2);
child1->add(child3);
root->operation();
delete root;
delete child1;
delete child2;
delete child3;
return 0;
}
安全式组合模式
#include <iostream>
#include <vector>
using namespace std;
class Component {
public:
virtual void operation() = 0;
};
class Leaf : public Component {
public:
void operation() override {
cout << "Leaf operation" << endl;
}
};
class Composite : public Component {
public:
void add(Component* c) {
children.push_back(c);
}
void remove(Component* c) {
for (auto it = children.begin(); it != children.end(); it++) {
if (*it == c) {
children.erase(it);
break;
}
}
}
void operation() override {
cout << "Composite operation" << endl;
for (auto child : children) {
child->operation();
}
}
private:
vector<Component*> children;
};
int main() {
Component* root = new Composite();
Component* child1 = new Composite();
Component* child2 = new Leaf();
Component* child3 = new Leaf();
root->operation();
if (auto composite = dynamic_cast<Composite*>(root)) {
composite->add(child1);
composite->add(child2);
}
if (auto composite = dynamic_cast<Composite*>(child1)) {
composite->add(child3);
}
root->operation();
delete root;
delete child1;
delete child2;
delete child3;
return 0;
}
组合模式的常见问题：
- 树形结构的遍历问题：由于组合模式中的对象组成了树形结构，因此在遍历这颗树的时候需要考虑如何遍历整个树形结构以及如何对叶子节点和组合节点进行不同的处理。
解决方案：组合模式提供了递归遍历组合结构中的所有对象的能力。遍历可以通过深度优先搜索或广度优先搜索两种方式实现。 - 叶子节点与组合节点的区别：在组合模式中，叶子节点表示最基本的对象，而组合节点表示由多个对象组成的复合对象。由于叶子节点和组合节点的行为不同，因此需要在程序设计中进行区分。
解决方案：组合模式中的叶子节点和容器节点具有相同的接口，因此可以通过添加一个标识符或者使用 instanceof 运算符来区分组合对象和叶子对象。 - 添加、删除节点的问题：由于组合模式是一个动态的结构，因此在运行时需要添加、删除节点。这样就需要考虑如何在保证整个树形结构正确的情况下，对节点进行添加、删除等操作。
解决方案：组合模式中的叶子节点和容器节点具有相同的接口，因此可以在不知道具体对象类型的情况下对其进行添加、删除操作。 - 安全性问题：由于组合模式允许客户端像处理单个对象一样处理对象的组合，因此可能会发生一些不合理的操作，例如对叶子节点进行添加子节点等。因此在设计组合模式时需要考虑如何保证程序的安全性。
解决方案：组合模式中的容器节点可以包含叶子节点和其他容器节点，因此在对容器节点进行操作时，需要确保只对容器节点进行操作，而不会对叶子节点进行操作。可以通过在容器节点中添加一个特殊的方法来实现安全性。 - 性能问题：由于组合模式需要遍历整个树形结构，因此在处理大规模数据时可能会存在性能问题。这时需要对程序进行优化，例如使用缓存、减少遍历次数等。
- 如何实现透明性？
解决方案：在组合模式中，叶子节点和容器节点具有相同的接口，这意味着用户可以使用相同的方式处理单个对象和对象组合。这种特性被称为透明性，可以提高代码的可维护性和可扩展性。