C++设计模式 之 “数据结构” 模式：Composite、Iterator、Chain of Resposibility

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

　　典型模式
　　#Composite
　　#Iterator
　　#Chain of Resposibility

part 1 Composite 模式

　　动机
　　#软件在某些情况下，客户代码过多地依赖于对象容器复杂的内部实现结构，对象容器内部实现结构（而非抽象接口）的变化将引起客户代码的频繁变化，带来了代码的维护性、拓展性等弊端。
　　#如何将“客户代码与复杂的对象容器结构”解耦？让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象一样来处理复杂的对象容器？

　　模式定义
　　将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性（稳定）。——《设计模式》GoF

　　结构

　　结构 from 《大话设计模式》

　　代码 from 《大话设计模式》

#include <iostream>
#include <string>
#include <set>

using namespace std;

struct Company;

using depth = unsigned;
using container = set<Company*>;

struct Company {
    virtual void display(depth d) = 0;
    virtual void lineDuty() = 0;
};

//brunch nood
struct ConcreteCompany : public Company {
    container childrens;
    string _name;

    ConcreteCompany(string name) : _name(name) {};

    virtual void display(depth d) override {
        for (depth i = 0; i < d; i++)
            cout << "-";
        
        cout << _name <<endl;

        for(auto e : this -> childrens)
            e->display(d + 1);
    }

    virtual void lineDuty() override {
        for (auto e : childrens)
            e->lineDuty();
    }

    void add(Company* c) {
        this -> childrens.insert(c);
    }

    void remove(Company* c) {
        this -> childrens.erase(c);
    }
};

//leaf nood
struct FinanceDepartment : public Company {
    string _name;

    FinanceDepartment(string name) : _name(name) {};
    
    virtual void display(depth d) override {
        for (depth i = 0; i < d; i++)
            cout << "-";

        cout << _name << endl;
    }

    virtual void lineDuty() override {
        cout << _name << "财务部 公司收支管理" << endl;
    }
};

//leaf nood
struct HRDepartment : public Company {
    string _name;

    HRDepartment(string name) : _name(name) {};

    virtual void display(depth d) override {
        for (depth i = 0; i < d; i++)
            cout << "-";

        cout << _name << endl;
    }

    virtual void lineDuty() override {
        cout << _name << "人力资源部 员工招聘培训管理" << endl;
    }
};

int main() {
    ConcreteCompany *root = new ConcreteCompany("北京总公司");
    root->add(new HRDepartment("总公司人力资源部"));
    root->add(new FinanceDepartment("总公司财务部"));

    ConcreteCompany *comp = new ConcreteCompany("上海华东分公司");
    comp->add(new HRDepartment("华东分公司人力资源部"));
    comp->add(new FinanceDepartment("华东分公司财务部"));
    root->add(comp);

    ConcreteCompany *comp1 = new ConcreteCompany("南京办事处");
    comp1->add(new HRDepartment("南京办事处人力资源部"));
    comp1->add(new FinanceDepartment("南京办事处财务部"));
    comp->add(comp1);

    ConcreteCompany *comp2 = new ConcreteCompany("杭州办事处");
    comp2->add(new HRDepartment("杭州办事处人力资源部"));
    comp2->add(new FinanceDepartment("杭州办事处财务部"));
    comp->add(comp2);

    cout << "结构图" << endl;
    root->display(1);

    cout << "职责" << endl;
    root->lineDuty();

    return 0;
}

　　要点总结
　　#Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化为“一对一”的关系，使得客户代码可以一致地（复用）处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。
　　#将“客户代码与复杂的对象容器结构”解耦的是Composite的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的内部实现结构——发生依赖，从而更能“应对变化”。
　　#Composite模式在具体实现中，可以让父对象中的字对象反向追溯；如果父对象有频繁的遍历需求，可以使用缓存技巧来改善效率。