设计模式--结构型模式--组合模式

//Structural Patterns--Composite
//结构型模式--组合模式

//Component（抽象构件）：为叶子构件和容器构件对象定义接口，可以包含所有子类共有行为的声明和实现。在抽象构件中，声明了访问及管理子构件的接口（例如：Add()、Remove()、GetChild() 等）。
//Leaf（叶子构件）：叶子节点没有子节点。它实现了 Component 中定义的行为，对于访问及管理子构件的接口，可以通过异常等方式进行处理。
//Composite（容器构件）：容器节点包含子节点（可以是叶子构件，也可以是容器构件）。它提供了一个集合用于存储子节点，实现了 Component 中定义的行为，包括访问及管理子构件的接口，
//在其业务方法中可以递归调用其子节点的业务方法。

//-----------------------------------------------------------
//Component（抽象构件）
class Component
{
public:
    Component(string name){m_strName = name;}
    virtual ~Component(){}

#if __DEFTM//透明组合模式
    virtual void Add(Component *comp) = 0;
    virtual void Remove(Component *comp1) = 0;
    virtual Component* GetChild(int index) = 0;
#endif
    virtual void Operation(int indent) = 0;

private:
    Component();
protected:
    string m_strName;
};
//-----------------------------------------------------------
//Leaf（叶子构件）
class Leaf : public Component
{
public:
    Leaf(string name):Component(name){}

    virtual ~Leaf(){}
#if __DEFTM//透明组合模式
    virtual void Add(Component *comp){cout << "Can`t add to a leaf."<<endl;}
    virtual void Remove(Component *comp1){cout << "Can`t remove from a leaf." << endl;}
    virtual Component* GetChild(int index){cout <<"Can`t get child from a leaf." << endl;return NULL;}
#endif
    virtual void Operation(int indent){string newStr(indent , '-');cout << newStr << " " << m_strName << endl;}
private:
    Leaf();
};
//-----------------------------------------------------------
//Composite（容器构件）
class Composite : public Component
{
public:
        Composite(string name):Component(name){}

    virtual ~Composite()
    {
        while(!m_elements.empty())
        {
            std::vector<Component*>::iterator it = m_elements.begin();
            if(*it != NULL) {delete *it ; *it = NULL;}
            m_elements.erase(it);
        }
    }

    virtual void Add(Component *comp)
    {
        m_elements.push_back(comp);
    }
    virtual void Remove(Component *comp)
    {
        std::vector<Component*>::iterator it = m_elements.begin();
        while(it != m_elements.end())
        {
            if(*it == comp)
            {
                m_elements.erase(it);
                if(comp != NULL) {delete comp ; comp = NULL;}
                break;
            }
            it++; 
        }
    }
    virtual Component* GetChild(int index)
    {
        if(index >= m_elements.size()) return NULL;
        return m_elements[index];
    }
    virtual void Operation(int indent)
    {
        string newStr(indent , '-');
        cout << newStr << "+ " << m_strName << endl;
        std::vector<Component*>::iterator it = m_elements.begin();
        while(it != m_elements.end())
        {
            (*it)->Operation(indent+2);
            ++it;
        }
    }

private:
    Composite();
    std::vector<Component *> m_elements;
};
//-----------------------------------------------------------
//测试
void dpCompositeTestMain()
{
#if __DEFTM//透明组合模式
    Component *pRoot = new Composite("江湖公司(任我行)");
#else//安全组合模式
    Composite *pRoot = new Composite("江湖公司(任我行)");
#endif

    //部门一
#if __DEFTM//透明组合模式
    Component *pDepart1 = new Composite("日月神教(东方不败)");
#else//安全组合模式
    Composite *pDepart1 = new Composite("日月神教(东方不败)");
#endif
    pDepart1->Add(new Leaf("光明左使(向问天)"));
    pDepart1->Add(new Leaf("光明右使(曲洋)"));

    pRoot->Add(pDepart1);

    //部门二
#if __DEFTM//透明组合模式
    Component *pDepart2 = new Composite("五岳剑派(左冷蝉)");
#else//安全组合模式
    Composite *pDepart2 = new Composite("五岳剑派(左冷蝉)");
#endif
    pDepart2->Add(new Leaf("嵩山(左冷蝉)"));
    pDepart2->Add(new Leaf("衡山(莫大)"));
    pDepart2->Add(new Leaf("华山(岳不群)"));
    pDepart2->Add(new Leaf("泰山(天门道长)"));
    pDepart2->Add(new Leaf("恒山(定闲师太)"));

    pRoot->Add(pDepart2);

    pRoot->Add(new Leaf("少林（方证大师）"));
    pRoot->Add(new Leaf("武当（冲虚道长）"));

    Component *pLeaf =  new Leaf("青城（余沧海）");
    pRoot->Add(pLeaf);

    pRoot->Remove(pLeaf);

    pRoot->Operation(1);

    if(pRoot != NULL){delete pRoot; pRoot = NULL;}

    return;

}