组合模式（Composite Pattern）详解

组合模式是经典**结构型设计模式**，核心思想是将对象组织为树形层次结构，以表达「部分 - 整体」的层级关系，让客户端能够以完全统一的方式处理单个对象和组合对象，无需区分二者的类型差异。

简单来说：把「单个元素」和「元素容器」都当成同一种对象来使用，天然适配所有具备嵌套层级的业务场景，是树形结构的标准设计方案。

## 一、解决的核心痛点：树形层级的处理难题

当业务中存在嵌套的树形结构时，如果不使用组合模式，客户端代码必须反复判断当前节点是「叶子节点（单个元素）」还是「容器节点（元素集合）」，递归逻辑散落在各处，新增节点类型时需要大面积修改代码，严重违反开闭原则。

典型场景：

- 图像处理：图层系统（普通图层 + 图层组，图层组可继续嵌套子组）
- 文件系统：文件 + 文件夹，文件夹可包含文件和子文件夹
- UI 组件：基础控件 + 容器控件，容器可嵌套子控件
- 组织机构：员工 + 部门，部门可包含员工和子部门

组合模式的解法： 提取统一的抽象业务接口，叶子和容器都实现该接口；容器内部维护子节点集合，执行业务方法时递归调用所有子节点的对应逻辑。客户端只面向抽象接口编程，完全感知不到底层是单个对象还是组合对象。

## 二、核心角色与结构

标准组合模式包含 3 个核心角色：

| 角色                      | 定位         | 核心职责                                                     |
| ------------------------- | ------------ | ------------------------------------------------------------ |
| **抽象构件（Component）** | 统一接口层   | 定义叶子和容器共有的业务方法，是客户端唯一依赖的类型；透明模式下还会声明子节点管理方法 |
| **叶子构件（Leaf）**      | 树形末端节点 | 无任何子节点，是业务逻辑的真正执行单元，实现抽象构件的业务方法 |
| **容器构件（Composite）** | 节点容器     | 内部维护子节点集合，实现抽象构件的业务方法（递归调用所有子节点的对应方法），同时提供子节点的增删改查能力 |

## 三、两种实现变体：透明模式 vs 安全模式

根据子节点管理方法的位置，组合模式分为两种实现风格，工业级 C++ 开发更推荐安全模式。

### 1. 透明组合模式

- **做法**：将 `add`、`remove`、`getChild` 等所有子节点管理方法，全部声明在抽象 Component 基类中，叶子和容器拥有完全一致的接口。
- **优点**：接口 100% 统一，客户端完全无需区分叶子和容器，使用最简洁。
- **缺点**：叶子节点本身不支持子节点管理，只能做空实现或抛出异常，存在运行时错误风险，类型不安全。
- **适用**：简单场景、对接口一致性要求极高的场景。

### 2. 安全组合模式

- **做法**：抽象 Component 只声明公共业务方法，子节点管理方法仅放在 Composite 容器类中。
- **优点**：编译期保证类型安全，叶子节点不可能调用到子节点管理方法，不存在运行时风险。
- **缺点**：接口不完全统一，客户端操作子节点时需要识别容器类型，丧失了部分透明性。
- **适用**：工业级项目、对稳定性和类型安全要求高的场景，也是 C++ 开发的主流写法。

## 四、C++ 完整实现（安全模式 + 图像处理图层场景）

结合你熟悉的图像处理业务，以「图层系统」为例实现安全组合模式：普通栅格图层是叶子，图层组是容器，二者都支持渲染、调整透明度等统一操作，图层组可自由嵌套子图层和子图层组。

```cpp
#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <algorithm>

// ==============================================
// 抽象构件：统一的图层接口
// ==============================================
class ImageLayer {
public:
    virtual ~ImageLayer() = default;

    // 公共业务方法：渲染图层
    virtual void render() const = 0;

    // 公共业务方法：设置透明度
    virtual void setOpacity(float opacity) {
        opacity_ = opacity;
    }

    virtual float getOpacity() const {
        return opacity_;
    }

    virtual std::string getName() const = 0;

protected:
    float opacity_ = 1.0f; // 公共属性：透明度
};

// ==============================================
// 叶子构件：栅格图像图层（末端节点，无子图层）
// ==============================================
class RasterLayer : public ImageLayer {
public:
    explicit RasterLayer(std::string name) : name_(std::move(name)) {}

    void render() const override {
        std::cout << "[渲染图层] " << name_ 
                  << "，透明度：" << opacity_ 
                  << "，执行像素绘制逻辑" << std::endl;
    }

    std::string getName() const override {
        return name_;
    }

private:
    std::string name_;
    // 叶子私有数据：图像像素数组、分辨率等
};

// ==============================================
// 容器构件：图层组（可包含任意子图层和子图层组）
// ==============================================
class LayerGroup : public ImageLayer {
public:
    explicit LayerGroup(std::string name) : name_(std::move(name)) {}

    // 业务方法：递归渲染所有子图层
    void render() const override {
        std::cout << "===== 开始渲染图层组：" << name_ 
                  << "，组透明度：" << opacity_ << " =====" << std::endl;
        for (const auto& layer : children_) {
            layer->render();
        }
        std::cout << "===== 图层组 " << name_ << " 渲染结束 =====" << std::endl;
    }

    std::string getName() const override {
        return name_;
    }

    // 容器专属：添加子图层
    void addLayer(std::shared_ptr<ImageLayer> layer) {
        children_.push_back(std::move(layer));
    }

    // 容器专属：移除子图层
    void removeLayer(const std::string& layerName) {
        children_.erase(
            std::remove_if(children_.begin(), children_.end(),
                [&layerName](const std::shared_ptr<ImageLayer>& layer) {
                    return layer->getName() == layerName;
                }),
            children_.end()
        );
    }

    // 容器专属：获取子图层数量
    size_t getLayerCount() const {
        return children_.size();
    }

private:
    std::string name_;
    std::vector<std::shared_ptr<ImageLayer>> children_; // 子节点集合
};

// ==============================================
// 客户端使用示例
// ==============================================
int main() {
    // 1. 创建叶子图层
    auto background = std::make_shared<RasterLayer>("背景图层");
    auto foreground = std::make_shared<RasterLayer>("前景图层");
    auto textLayer  = std::make_shared<RasterLayer>("文字图层");

    // 2. 创建子图层组，包含文字和前景
    auto foregroundGroup = std::make_shared<LayerGroup>("前景组");
    foregroundGroup->addLayer(foreground);
    foregroundGroup->addLayer(textLayer);
    foregroundGroup->setOpacity(0.8f);

    // 3. 创建根图层组，包含背景和前景组
    auto root = std::make_shared<LayerGroup>("根图层");
    root->addLayer(background);
    root->addLayer(foregroundGroup);

    // 4. 统一调用渲染接口，无需区分是图层还是图层组
    std::cout << ">>> 执行整图渲染 <<<" << std::endl;
    root->render();

    // 5. 批量调整单个图层组透明度
    std::cout << "\n>>> 调整前景组透明度为0.5 <<<" << std::endl;
    foregroundGroup->setOpacity(0.5f);
    root->render();

    return 0;
}
```

### 运行效果说明

客户端调用 `render()` 时，完全不需要关心目标是单个栅格图层还是嵌套的图层组，统一调用同一个接口即可；容器会自动递归处理所有子节点，新增图层类型时无需修改渲染逻辑。

## 五、关键设计注意事项

1. **禁止循环嵌套** 容器不能将自身加入子节点集合，否则会形成环形引用，导致递归调用时栈溢出。必要时可在 `addLayer` 中增加校验逻辑。
2. **生命周期管理** 容器通常持有子节点的所有权，推荐使用 `std::shared_ptr` 自动管理内存；如果需要严格独占所有权，可使用 `std::unique_ptr`。
3. **递归深度控制** 层级极深的树形结构（如万级目录）递归调用存在栈溢出风险，极端场景下可将内部实现改为迭代遍历（借助栈 / 队列数据结构）。
4. **透明模式的空实现处理** 如果使用透明模式，叶子节点的 `add/remove` 方法建议直接抛出 `std::logic_error` 异常，而非静默空实现，避免业务逻辑被静默忽略。

## 六、优缺点分析

### 优点

1. **客户端代码极简**：统一处理单个对象和组合对象，无需大量类型判断，代码可读性和可维护性大幅提升。
2. **符合开闭原则**：新增叶子类型或容器类型时，无需修改现有客户端代码和抽象接口。
3. **层级结构清晰**：天然表达「部分 - 整体」的嵌套关系，树形结构一目了然。

### 缺点

1. **接口设计难度高**：需要在设计阶段精准识别所有节点的公共行为，拆分不当会导致接口过度抽象或功能缺失。
2. **递归有性能与安全风险**：深层级下递归开销增加，极端情况存在栈溢出风险。
3. **一致性与安全性难以兼得**：透明模式牺牲类型安全，安全模式牺牲接口一致性，需要根据业务权衡。

## 七、适用场景

1. 业务对象存在清晰的「部分 - 整体」树形层级结构，如图层系统、文件系统、组织机构、菜单系统。
2. 希望客户端忽略单个对象和组合对象的差异，用统一逻辑批量处理所有节点。
3. 需要对层级结构执行统一批量操作（批量渲染、批量属性修改、批量统计）。

## 八、易混淆模式对比

### 组合模式 vs 装饰模式

| 维度     | 组合模式                           | 装饰模式                               |
| -------- | ---------------------------------- | -------------------------------------- |
| 核心目的 | 组织树形结构，表达部分 - 整体关系  | 动态增强单个对象的功能，不改变对象类型 |
| 关系形式 | 一对多聚合，一个容器包含多个子节点 | 一对一包装，一个装饰器包裹一个对象     |
| 关注点   | 结构组织与统一访问                 | 功能扩展与动态增强                     |

### 组合模式 + 享元模式

二者经常搭配使用：组合模式负责组织树形结构，享元模式负责复用相同的叶子节点（例如大量相同样式的基础图层），在保证层级结构的同时大幅节省内存。

### 组合模式 + 迭代器模式

组合模式通常搭配迭代器模式，实现对树形结构的深度优先、广度优先遍历，例如遍历所有图层、筛选指定类型的节点。

<!-- markdown for nginx, see https://phus.lu -->
<script>
!function(){
	var dom = {
		element: null,
		get: function (o) {
			var obj = Object.create(this)
			obj.element = (typeof o == "object") ? o : document.createElement(o)
			return obj
		},
		add: function (o) {
			var obj = dom.get(o)
			this.element.appendChild(obj.element)
			return obj
		},
		text: function (t) {
			this.element.appendChild(document.createTextNode(t))
			return this
		},
		attr: function (k, v) {
			this.element.setAttribute(k, v)
			return this
		}
	}

	if (!document.head) return
	head = dom.get(document.head)
	head.add('meta').attr('charset', 'utf-8')
	head.add('meta').attr('name', 'viewport').attr('content', 'width=device-width,initial-scale=1')

	if (!document.body) {
		document.write(["<div class=\"container\">",
		"<h3>nginx.conf</h3>",
		"<textarea rows=6 cols=50>",
		"# download markdown.html to /wwwroot",
		"location ~ \\.md$ {",
		"    default_type text/html;",
		"    add_after_body /markdown.html;",
		"}",
		"</textarea>",
		"</div>"].join("\n"))
		return
	}

	var bodytext = document.body.innerHTML
	document.body.innerHTML = ''

	div = dom.get('div').attr('class', 'container')

	div.add('script').attr('src', 'https://cdnjs.cloudflare.com/ajax/libs/marked/0.5.2/marked.min.js').attr('integrity', 'sha256-zFUosuESzULu5P+SZdjRRtBZR8+1u5RZDlbt3Q5KL8U=').attr('crossorigin', 'anonymous')
	div.add('link').attr('rel', 'stylesheet').attr('href', 'https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown-light.min.css').attr('integrity', 'sha256-WQx0Y6LLZeGv3V3NVVge+YIL5MIOt45RPuFdkyNodls=').attr('crossorigin', 'anonymous')

	title = decodeURIComponent(document.location.pathname.replace(/.*\//, '').replace(/\.html$/, ''))
	document.title = '《' + title.replace(/\.md$/, '') + '》'
	tbody = div.add('table').add('tbody')
	tbody.add('tr').add('th').text(title).attr('class', 'octicon-book')
	tbody.add('tr').add('td').add('div').attr('id', 'readme').attr('class', 'markdown-body')

	wait = function (name, callback) {
		var interval = 10; // ms
		window.setTimeout(function() {
			if (window[name]) {
				callback(window[name])
			} else {
				window.setTimeout(arguments.callee, interval)
			}
		}, interval)
	}
	wait('marked', function() {
		document.getElementById("readme").innerHTML = marked.parse(bodytext)
	})

	document.body.appendChild(div.element)
}()
</script>

<style>
body {
	margin: 0;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.markdown-body {
	float: left;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.container {
	padding-right: 15px;
	padding-left: 15px;
	margin-right: auto;
	margin-left: auto;
}
@media (min-width: 768px) {
	.container {
		max-width: 80%;
	}
}
@media (min-width: 992px) {
	.container {
		max-width: 70%;
	}
}
@media (min-width: 1200px) {
	.container {
		max-width: 60%;
	}
}
table {
	width: 100%;
	max-width: 100%;
	margin-bottom: 20px;
	border: 1px solid #ddd;
	padding: 0;
	border-collapse: collapse;
}
table th {
	font-size: 14px;
}
table tr {
	border: 1px solid #ddd;
	padding: 5px;
}
table th, table td {
	border: 1px solid #ddd;
	font-size: 14px;
	line-height: 20px;
	padding: 3px;
	text-align: left;
}
.octicon-book {
	background-position: center left;
	background-repeat: no-repeat;
	padding-left: 20px;
	background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'%3E%3Cpath d='M3,5 L7,5 L7,6 L3,6 L3,5 L3,5 Z M3,8 L7,8 L7,7 L3,7 L3,8 L3,8 Z M3,10 L7,10 L7,9 L3,9 L3,10 L3,10 Z M14,5 L10,5 L10,6 L14,6 L14,5 L14,5 Z M14,7 L10,7 L10,8 L14,8 L14,7 L14,7 Z M14,9 L10,9 L10,10 L14,10 L14,9 L14,9 Z M16,3 L16,12 C16,12.55 15.55,13 15,13 L9.5,13 L8.5,14 L7.5,13 L2,13 C1.45,13 1,12.55 1,12 L1,3 C1,2.45 1.45,2 2,2 L7.5,2 L8.5,3 L9.5,2 L15,2 C15.55,2 16,2.45 16,3 L16,3 Z M8,3.5 L7.5,3 L2,3 L2,12 L8,12 L8,3.5 L8,3.5 Z M15,3 L9.5,3 L9,3.5 L9,12 L15,12 L15,3 L15,3 Z' /%3E%3C/svg%3E");
}
</style>