组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

意图

将对象组合成树形结构以表示”部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

主要解决

它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

何时使用

  1. 您想表示对象的部分-整体层次结构（树形结构）。
  2. 您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

如何解决

树枝和叶子实现统一接口，树枝内部组合该接口。

关键代码

树枝内部组合该接口，并且含有内部属性 List，里面放 Component。

应用实例

  1. 算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数。
  2. 在 JAVA AWT 和 SWING 中，对于 Button 和 Checkbox 是树叶，Container 是树枝。

优点

  1. 高层模块调用简单。
  2. 节点自由增加。

缺点

在使用组合模式时，其叶子和树枝的声明都是实例，而不是接口，违反了依赖倒置原则。

使用场景

部分、整体场景，如树形菜单，文件、文件夹的管理。

示例

员工的下属也是员工的集合，下面的示例中有5个员工A、B、C、D、E，B、C为A下属，D、E为B下属。假如需要对所有人增加1000工资，组合模式能同时使A和其下属生效。
image.png

  1. #include "pch.h"
  2. #include <iostream>
  3. #include <vector>
  4. #include <algorithm>
  6. class Employee
  7. {
  8. public:
  9.     // 构造
  10.     Employee(int ID, std::string name, int salary)
  11.         : ID(ID)
  12.         , name(name)
  13.         , salary(salary)
  14.     { }
  16.     // 添加下属
  17.     void Add(Employee* const e)
  18.     {
  19.         this->subordinates.push_back(e);
  20.     }
  22.     // 删除下属
  23.     void Remove(const Employee* const e)
  24.     {
  25.         std::vector<Employee*>::iterator it = std::find(subordinates.begin(), subordinates.end(), e);
  26.         this->subordinates.erase(it);
  27.     }
  29.     // 获取下属
  30.     std::vector<Employee*> GetSubordinates()
  31.     {
  32.         return subordinates;
  33.     }
  35.     // 增加薪水
  36.     void AddSalary(int salary)
  37.     {
  38.         this->salary += salary;
  39.         for (Employee* e : subordinates)
  40.         {
  41.             e->AddSalary(salary);
  42.         }
  43.     }
  45.     // 打印信息该节点信息，level用来控制最前面的空格使打印成树形结构
  46.     void PrintInfo(int level=0)
  47.     {
  48.         for (int i = 0; i < level; ++i)
  49.         {
  50.             std::cout << "  ";
  51.         }
  52.         std::cout << "[Name:" << this->name.c_str() << " Salary:" << this->salary << "]" << std::endl;
  53.         for (Employee* e : subordinates)
  54.         {
  55.             e->PrintInfo(level + 1);
  56.         }
  57.     }
  59.     bool operator== (const Employee* const e)
  60.     {
  61.         return this->ID == e->ID;
  62.     }
  64. private:
  65.     int ID;
  66.     int salary;
  67.     std::string name;
  68.     std::vector<Employee*> subordinates;
  69. };
  71. /*--------------------------------
  72.     A
  73.     |
  74.     +————B
  75.     |    |
  76.     |    +————D
  77.     |    |
  78.     |    +————E
  79.     |
  80.     +————C
  81. --------------------------------*/
  82. // 调用示例
  83. int main()
  84. {
  85.     Employee A(1, "A", 20000);
  86.     Employee B(2, "B", 13000);
  87.     Employee C(3, "C", 10000);
  88.     Employee D(4, "D", 10000);
  89.     Employee E(5, "E", 12000);
  91.     B.Add(&D);
  92.     B.Add(&E);
  93.     A.Add(&B);
  94.     A.Add(&C);
  96.     A.PrintInfo();
  98.     std::cout << std::endl << "Add salary 1000 to all ..." << std::endl << std::endl;
  99.     A.AddSalary(1000);
  100.     A.PrintInfo();
  101. }
>>>
[Name:A Salary:20000]
  [Name:B Salary:13000]
    [Name:D Salary:10000]
    [Name:E Salary:12000]
  [Name:C Salary:10000]

Add salary 1000 to all ...

[Name:A Salary:21000]
  [Name:B Salary:14000]
    [Name:D Salary:11000]
    [Name:E Salary:13000]
  [Name:C Salary:11000]