常常有一些组建在内部具有特定的数据结构，如果让客户程序依赖这些特定的数据结构，将极大的破坏组件的复用。这时候，将这些数据结构封装在内部，在外部提供统一的接口，来实现与特定数据结构无关的访问，是一种行之有效的解决方案。

组合模式：Composite

迭代器模式：Iterator

责任链模式：Chain of Responsibility

通过递归手段来构造树形对象结构并可以通过一个对象来访问整个对象

软件在某些情况下，客户代码过多地依赖于对象容器复杂的内部实现结构，对象容器内部实现结构（而非抽象接口）的变化将因其客户代码的频繁变化，带来了代码的维护性、扩展性等弊端。

如何将“客户代码与复杂的对象容器结构”解耦？让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象一样来处理复杂的对象容器？

将对象组合成树形结构以表示“部分-整体”的层级结构。Compisite使得用户对单个对象和组合对象的使用具有一致性 （稳定）。

                                                                              ——《设计模式》GoF

class Component

{

public:

    virtual void process() = ;

    virtual ~Component(){}

};

//树节点

class Composite : public Component{

    string name;

    list<Component*> elements;　　//表达了一个树形结构

public:

    Composite(const string & s) : name(s) {}

    void add(Component* element) {

        elements.push_back(element);

    }

    void remove(Component* element){

        elements.remove(element);

    }

    void process(){

        //1. process current node

        //2. process leaf nodes

        for (auto &e : elements)　　//会出现多态递归调用，可能是树节点也可能是叶子节点

            e->process(); //多态调用

    }

};

//叶子节点

class Leaf : public Component{

    string name;

public:

    Leaf(string s) : name(s) {}

    void process(){

        //process current node

    }

};

void Invoke(Component & c){　　//可以是树节点或者叶子节点

    //...

    c.process();　　//多态调用

    //...

}

int main()

{

    Composite root("root");

    Composite treeNode1("treeNode1");

    Composite treeNode2("treeNode2");

    Composite treeNode3("treeNode3");

    Composite treeNode4("treeNode4");

    Leaf leat1("left1");

    Leaf leat2("left2");

    root.add(&treeNode1);

    treeNode1.add(&treeNode2);

    treeNode2.add(&leaf1);

    root.add(&treeNode3);

    treeNode3.add(&treeNode4);

    treeNode4.add(&leaf2);

    Invoke(root);

    Invoke(leaf2);

    Invoke(treeNode3);

}

//树节点

class Composite : public Component{

    string name;

    list<Component*> elements;

public:

    Composite(const string & s) : name(s) {}

    void add(Component* element) {

        elements.push_back(element);

    }

    void remove(Component* element){

        elements.remove(element);

    }

    void process(){

        //1. process current node

    }

};

//叶子节点

class Leaf : public Component{

    string name;

public:

    Leaf(string s) : name(s) {}

    void process(){

        //process current node

    }

};

void Invoke(Component & c){

    //...

    c.process();　　//这个地方的处理要做分别处理，进行判断类别，然后进行递归，依赖于对象容器内部的复杂结构

    //...

}

若是不用composite模式，我们在Invoke中需要进行多种判断类型，是一对多，但是我们使用了composite模式，我们只需要使用一个process即可，无需更新内部是什么，统一处理

//抽象接口

class Component

{

public:

    virtual void display() = ;

    virtual ~Component(){}

};

//树形结构,文件夹

class Folder :public Component

{

private:

    string f_name;

    list<Component*> f_list;

public:

    Folder(string name)

    {

        f_name = name;

    }

    virtual void display()

    {

        cout << "d\t" << f_name << endl;

        for (auto &f : f_list)

            f->display();

    }

    void Add(Component* comp)

    {

        f_list.push_back(comp);

    }

    void Remove(Component* comp)

    {

        f_list.remove(comp);

    }

    list<Component*> GetChild()

    {

        return f_list;

    }

};

//叶子节点，文件

class File :public Component

{

private:

    string f_name;

public:

    File(string name)

    {

        f_name = name;

    }

    virtual void display()

    {

        cout << "f\t" << f_name << endl;

    }

};

void main()

{

    Folder* root = new Folder("C:");

    Folder* dir1 = new Folder("System32");

    Folder* dir2 = new Folder("drivers");

    Folder* dir3 = new Folder("etc");

    File* file1 = new File("SAII_LOG.TXT");

    File* file2 = new File("hosts");

    root->Add(dir1);

    dir1->Add(dir2);

    dir1->Add(file1);

    dir2->Add(dir3);

    dir3->Add(file2);

    root->display();

    cout << "==========================" << endl;

    dir3->Remove(file2);

    File* file3 = new File("config.ini");

    dir3->Add(file3);

    root->display();

    delete dir1;

    delete dir2;

    delete dir3;

    delete file1;

    delete file2;

    delete file3;

    system("pause");

    return;

}