设计模式-组合模式

1.组合模式：

    特点:

        多个对象形成树形结构以表示“整体-部分”的结构层次,并且对待单个对象和整体对象的处理方式是一致的.该模式适用于具有层次的，部分-整体结构模型。

例如，部门-子部门模型,就适合使用

        该模型处理,另外可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构件也更容易。

    种类：

        1)安全组合模式：将管理子元素的方法定义在Composite类中。

        2)透明组合模式：将管理子元素的方法定义在Component接口中，这样Leaf类就需要对这些方法空实现。

    缺点：

        1)使设计变得更加抽象,对象的业务规则如果很复杂，则实现组合模式具有很大挑战性，而且不是所有的方法都与叶子对象子类都有关联。

        2)增加新构件时可能会产生一些问题，很难对容器中的构件类型进行限制。

2, 示范代码

/*
组合模式：
    特点:
        多个对象形成树形结构以表示“整体-部分”的结构层次,并且对待单个对象和整体对象的处理方式是一致的.该模式适用于具有层次的，部分-整体结构模型。

例如，部门-子部门模型,就适合使用
        该模型处理,另外可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构件也更容易。


    种类：
        1)安全组合模式：将管理子元素的方法定义在Composite类中。


        2)透明组合模式：将管理子元素的方法定义在Component接口中，这样Leaf类就需要对这些方法空实现。


    缺点：
        1)使设计变得更加抽象,对象的业务规则如果很复杂，则实现组合模式具有很大挑战性，而且不是所有的方法都与叶子对象子类都有关联。


        2)增加新构件时可能会产生一些问题，很难对容器中的构件类型进行限制。


*/

#include 
#include 
#include 
#include 
#include 

class myCompose
{
    protected:
        /* data */
        std::string comName_;
    public:
        myCompose(std::string name){
            comName_ = name;
        }
        ~myCompose(){}
        virtual void Add(myCompose* p)=0;
        virtual void Remove(myCompose* p)=0;
        virtual void Display()=0;
};

// 叶子节点
class leaf:public myCompose
{
    private:
        /* data */
    public:
        leaf(std::string name):myCompose(name)
        {
        }

        void Add(myCompose * p)
        {
           
        }
        void Remove(myCompose * p)
        {
           
        }
        void Display()
        {
          
        }

        ~leaf()
        {

        }
};

// 非叶子节点
class myComposeSon:public myCompose
{
    private:
        std::vector> vecCome_; // 存储组合的子对象
    public:
        myComposeSon(std::string name):myCompose(name){}
        ~myComposeSon()
        {
            if(!vecCome_.empty())
            {
                vecCome_.clear();
            }
        }

        void Add(myCompose*p)
        {
            auto it = find_if(vecCome_.begin(),vecCome_.end(),[p](std::shared_ptr ptr){return p == ptr.get();});
            if(it == vecCome_.end())
                vecCome_.push_back(std::shared_ptr(p));
            
        }

        void Remove(myCompose*p)
        {
            auto it = find_if(vecCome_.begin(),vecCome_.end(),[p](std::shared_ptr ptr){return p == ptr.get();});
            if(it == vecCome_.end())
                return;
            vecCome_.erase(it);
        }

        void Display()
        {
            std::cout<Display();
            }       
        }

};

int main()
{
    myCompose* p = new myComposeSon("首都");
    p->Add(new leaf("首都行政中心"));
    p->Add(new leaf("首都人力中心"));

    myCompose* p1 = new myComposeSon("省份");
    p1->Add(new leaf("省份人力资源部"));
    p1->Add(new leaf("省份财务部"));

    // 组合成一个嵌套树形结构,但是部分跟整体的处理方式是一致的
    p->Add(p1);
    p->Display();
    return 0;
}

结果：
[root@localhost c++]# ./a.out 
首都
首都行政中心
首都人力中心
省份
省份人力资源部
省份财务部