0. 简介

这一次我们继续来讲结构型模式中的组合设计模式。组合模式是一种结构型设计模式， 你可以使用它将对象组合成树状结构， 并且能像使用独立对象一样使用它们。
在一般组合模式中中声明所有用来管理子对象的方法，其中包括Add、Remove等，这样实现组合方法接口的所有子类都具备了Add和Remove，但是只是是虚函数，并不会去使用。

1. 组合模式结构

如下图所示为组合模式的示意图，主要的核心部分为容器部分（Composite），它是含有子组件的类.
在这里插入图片描述

  1. 组件(Component)：为组合中的对象声明接口，声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数)，声明一个接口函数可以访问Component的子组件。
    1). Component::ComponentPtr:定义了各个组件共有的行为接口，由各个组件的具体实现.
    2). Component::add添加一个子组件
    3). Component::remove::删除一个子组件.
    4). Component::display:获得子组件的指针.

  2. 容器(Composite)：是含有子组件的类，其内部包含了多种方法，主要是在当中实现了add与remove这类的操作用于对子组件进行控制。

  3. 叶节点(Leaf)：是叶子结点,也就是不含有子组件的结点。

2. 组合模式示例

组合模式的操作代表着其可以很多种相似的操作，并在调用时可以统一的调用出来。组合模式的核心思想就是：一个组织有很多子组织，而无论子组织是单独一个部门或是一个分组织。该组织都希望把它们当成一样的子组织来管理。对于分组织，只用通知分组织就可以了，而不用一一通知分组织的各个部门。

// CompositeModel.h文件
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

class ComponentPtr
{
protected:
    std::string m_strName;
public:
    ComponentPtr(std::string str)
    {
        m_strName = str;
    }
    virtual void add(ComponentPtr * p) = 0;
    virtual void remove(ComponentPtr * p) = 0;
    virtual void display() = 0;
};

class LeafPtr : public ComponentPtr
{
public:
    LeafPtr(std::string str) : ComponentPtr(str) {}
    void add(ComponentPtr * p)
    {
        std::cout << "Leaf cannot add" << std::endl;
    }
    void remove(ComponentPtr * p)
    {
        std::cout << "Leaf cannot remove" << std::endl;
    }
    void display()
    {
        std::cout << m_strName << std::endl;
    }
};

class CompositePtr : public ComponentPtr
{
private:
    // 这里使用智能指针不用自己释放new的内存
    std::vector<std::shared_ptr<ComponentPtr>> m_vec;
public:
    CompositePtr(std::string str) : ComponentPtr(str) {};
    ~CompositePtr()
    {
        if (!m_vec.empty())
        {
            m_vec.clear();
        }
    }
    void add(ComponentPtr * p)
    {
        auto it = find_if(m_vec.begin(), m_vec.end(), 
            [p](std::shared_ptr<ComponentPtr> ptr) {return p == ptr.get(); });
        if (it == m_vec.end())
            m_vec.push_back(std::shared_ptr<ComponentPtr>(p));
    }
    void remove(ComponentPtr * p)
    {
        auto it = find_if(m_vec.begin(), m_vec.end(),
            [p](std::shared_ptr<ComponentPtr> ptr) {return p == ptr.get(); });
        if (it == m_vec.end())
            return;
        m_vec.erase(it);
    }
    void display()
    {
        for (auto it = m_vec.cbegin(); it != m_vec.cend(); it++)
        {
            (*it)->display();
        }
    }
};


/**#include <iostream>
#include "CompositeModel.h"

int main()
{
    using namespace std;
    // 组合模式
    CompositePtr * p = new CompositePtr("总部");
    p->add(new LeafPtr("总部财务部门"));
    p->add(new LeafPtr("总部人力资源部门"));
    CompositePtr * p1 = new CompositePtr("上海分部");
    p1->add(new LeafPtr("上海分部财务部门"));
    p1->add(new LeafPtr("上海分部人力资源部门"));
    p->add(p1);
    p->display();
    getchar()
    return 0;
}**/

3. 组合模式的优劣

组合和我们之前讲的装饰模式的结构图很相似， 因为两者都依赖递归组合来组织无限数量的对象。装饰类似于组合， 但其只有一个子组件。 此外还有一个明显不同： 装饰为被封装对象添加了额外的职责， 组合仅对其子节点的结果进行了 “求和”。但是， 模式也可以相互合作： 你可以使用装饰来扩展组合树中特定对象的行为。

大量使用组合和装饰的设计通常可从对于原型模式的使用中获益。 你可以通过该模式来复制复杂结构， 而非从零开始重新构造。
在这里插入图片描述

4. 参考链接

https://blog.csdn.net/konglongdanfo1/article/details/83381267

https://www.cnblogs.com/jiese/p/3168844.html

https://refactoringguru.cn/design-patterns/composite