組合模式（Composite Pattern）是一種【結構型】設計模式，它允許你將對象組合成樹形結構以表示 “部分 - 整體” 的層次關系。這種模式使得客戶端可以統一處理單個對象和對象組合，無需區分它們的具體類型。

一、模式核心概念與結構

組合模式包含三個核心角色：

1. 組件（Component）：定義組合中所有對象的通用接口，聲明管理子組件的方法。
2. 葉節點（Leaf）：表示組合中的葉節點對象，沒有子節點，實現組件接口。
3. 組合節點（Composite）：表示組合中的分支節點，包含子組件，實現組件接口并管理子組件。

二、C++ 實現示例：文件系統

以下是一個經典的組合模式示例，演示如何用組合模式表示文件系統：

#include <iostream>
#include <string>
#include <vector>
#include <memory>// 組件：文件系統元素
class FileSystemElement {
public:virtual ~FileSystemElement() = default;virtual void print(int depth = 0) const = 0;virtual size_t getSize() const = 0;virtual void add(std::shared_ptr<FileSystemElement> element) {}virtual void remove(std::shared_ptr<FileSystemElement> element) {}
};// 葉節點：文件
class File : public FileSystemElement {
private:std::string name;size_t size;public:File(const std::string& n, size_t s) : name(n), size(s) {}void print(int depth) const override {std::cout << std::string(depth * 2, ' ') << "- " << name << " (file, " << size << " bytes)" << std::endl;}size_t getSize() const override {return size;}
};// 組合節點：目錄
class Directory : public FileSystemElement {
private:std::string name;std::vector<std::shared_ptr<FileSystemElement>> children;public:Directory(const std::string& n) : name(n) {}void print(int depth) const override {std::cout << std::string(depth * 2, ' ') << "+ " << name << " (directory, " << getSize() << " bytes)" << std::endl;for (const auto& child : children) {child->print(depth + 1);}}size_t getSize() const override {size_t total = 0;for (const auto& child : children) {total += child->getSize();}return total;}void add(std::shared_ptr<FileSystemElement> element) override {children.push_back(element);}void remove(std::shared_ptr<FileSystemElement> element) override {for (auto it = children.begin(); it != children.end(); ++it) {if (*it == element) {children.erase(it);break;}}}
};// 客戶端代碼
int main() {// 創建目錄結構auto root = std::make_shared<Directory>("/");auto home = std::make_shared<Directory>("home");auto user = std::make_shared<Directory>("user");auto docs = std::make_shared<Directory>("documents");// 添加文件docs->add(std::make_shared<File>("report.txt", 1024));docs->add(std::make_shared<File>("presentation.pdf", 5120));user->add(docs);user->add(std::make_shared<File>("profile.jpg", 2048));home->add(user);root->add(home);root->add(std::make_shared<File>("readme.txt", 512));// 打印文件系統結構root->print();// 計算總大小std::cout << "\nTotal size: " << root->getSize() << " bytes" << std::endl;return 0;
}

三、組合模式的關鍵特性

1. 統一接口：
   • 組件接口定義了葉節點和組合節點的共同行為（如print()、getSize()）。
   • 客戶端可以一致地處理單個對象和對象組合。
2. 遞歸結構：
   • 組合節點可以包含其他組合節點或葉節點，形成樹形結構。
   • 操作可以遞歸地應用于整個樹結構。
3. 透明性 vs 安全性：
   • 透明性：在組件接口中聲明所有管理子節點的方法（如add()、remove()），使葉節點和組合節點具有相同接口，但可能導致葉節點運行時錯誤。
   • 安全性：僅在組合節點中聲明管理子節點的方法，葉節點不包含這些方法，但客戶端需區分葉節點和組合節點。

四、應用場景

1. 樹形結構表示：
   • 文件系統、XML/JSON 解析樹。
   • 組織結構圖、菜單系統。
2. 統一處理對象：
   • 圖形編輯器中的形狀組合（如 Group、Layer）。
   • 游戲中的場景圖（Scene Graph）。
3. 遞歸操作：
   • 數學表達式計算（如加減乘除組合）。
   • 權限管理中的角色和權限組。

五、組合模式與其他設計模式的關系

1. 迭代器模式：
   • 組合模式常與迭代器模式結合，用于遍歷樹形結構。
   • 例如，使用迭代器遍歷文件系統中的所有文件。
2. 訪問者模式：
   • 組合模式可以配合訪問者模式，將算法與對象結構分離。
   • 例如，通過訪問者模式實現文件系統的大小統計、搜索等操作。
3. 享元模式：
   • 組合模式的葉節點可以是享元對象，共享內部狀態以節省內存。
   • 例如，文件系統中的相同文件可以共享同一個對象實例。

六、C++ 標準庫中的組合模式應用

1. STL 容器：
   • std::vector、std::list等容器可以存儲不同類型的元素，形成樹形結構。
   • 例如，std::vector<std::shared_ptr<Component>>可以存儲組合節點和葉節點。
2. 智能指針：
   • std::shared_ptr和std::unique_ptr可用于管理組合結構中的對象生命周期。
   • 例如，在文件系統示例中使用std::shared_ptr避免內存泄漏。
3. 流類庫：
   • std::iostream層次結構中，std::iostream是抽象組件，std::ifstream和std::ofstream是葉節點，std::stringstream可視為組合節點。

七、優缺點分析

優點：

• 簡化客戶端代碼：客戶端無需區分處理葉節點和組合節點。
• 靈活擴展：可以輕松添加新的葉節點或組合節點。
• 樹形結構清晰：明確表示 “部分 - 整體” 的層次關系。

缺點：

• 限制類型安全：透明實現可能導致運行時錯誤（如對葉節點調用add()）。
• 設計復雜度：在某些情況下，過度使用組合模式可能使設計變得復雜。
• 性能問題：遞歸操作可能導致性能開銷，尤其是大型樹結構。

八、實戰案例：圖形編輯器

以下是一個圖形編輯器的組合模式實現：

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <cmath>// 組件：圖形元素
class Shape {
public:virtual ~Shape() = default;virtual void draw() const = 0;virtual double area() const = 0;virtual void add(std::shared_ptr<Shape> shape) {}virtual void remove(std::shared_ptr<Shape> shape) {}
};// 葉節點：圓形
class Circle : public Shape {
private:double radius;std::string color;public:Circle(double r, const std::string& c) : radius(r), color(c) {}void draw() const override {std::cout << "Drawing Circle with radius " << radius << " and color " << color << std::endl;}double area() const override {return M_PI * radius * radius;}
};// 葉節點：矩形
class Rectangle : public Shape {
private:double width, height;std::string color;public:Rectangle(double w, double h, const std::string& c) : width(w), height(h), color(c) {}void draw() const override {std::cout << "Drawing Rectangle with width " << width << ", height " << height << " and color " << color << std::endl;}double area() const override {return width * height;}
};// 組合節點：圖形組
class Group : public Shape {
private:std::string name;std::vector<std::shared_ptr<Shape>> shapes;public:Group(const std::string& n) : name(n) {}void draw() const override {std::cout << "Group " << name << " contains:" << std::endl;for (const auto& shape : shapes) {shape->draw();}}double area() const override {double total = 0;for (const auto& shape : shapes) {total += shape->area();}return total;}void add(std::shared_ptr<Shape> shape) override {shapes.push_back(shape);}void remove(std::shared_ptr<Shape> shape) override {for (auto it = shapes.begin(); it != shapes.end(); ++it) {if (*it == shape) {shapes.erase(it);break;}}}
};// 客戶端代碼
int main() {// 創建圖形元素auto circle = std::make_shared<Circle>(5.0, "red");auto rectangle = std::make_shared<Rectangle>(4.0, 6.0, "blue");// 創建圖形組auto group1 = std::make_shared<Group>("Group 1");group1->add(circle);group1->add(rectangle);// 創建另一個圖形組并添加子組auto group2 = std::make_shared<Group>("Group 2");auto anotherCircle = std::make_shared<Circle>(3.0, "green");group2->add(anotherCircle);group2->add(group1);  // 添加子組// 繪制所有圖形group2->draw();// 計算總面積std::cout << "\nTotal area: " << group2->area() << std::endl;return 0;
}

九、實現注意事項

1. 內存管理：
   • 使用智能指針（如std::shared_ptr）管理組合結構中的對象生命周期。
   • 避免循環引用導致內存泄漏（可使用std::weak_ptr）。
2. 接口設計：
   • 根據需要選擇透明性（在基類中聲明所有方法）或安全性（僅在組合類中聲明特定方法）。
3. 遞歸深度：
   • 對于大型樹結構，遞歸操作可能導致棧溢出，考慮使用迭代或尾遞歸優化。
4. 線程安全：
   • 在多線程環境中，修改組合結構（如add()、remove()）需考慮同步問題。

組合模式是 C++ 中處理樹形結構的重要工具，通過統一接口和遞歸組合，使客戶端可以一致地處理單個對象和對象組合，從而簡化了代碼設計并提高了系統的可擴展性。

---

如果這篇文章對你有所幫助，渴望獲得你的一個點贊！