11.组合模式--Composite

 

Composite模式：
Composite模式将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。在Composite模式中，基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断递归下去，客户代码中，任何使用到基本对象的地方都可以使用组合对象了。

当需求中是体现部分与整体层次的结构时，以及希望用户可以忽略组合对象与单一对象的不同，统一的使用组合结构中的所有对象时，就应该考虑用组合模式。比如文本编辑处理，既可以对单个文字进行字体、颜色等的转换，也可以对一个词组，或一个段落，或整篇文章进行字体、颜色等的转换。

Component模式是为解决组件之间的递归组合提供了解决的办法,它主要分为两个派生类,其中的Leaf是叶子结点,也就是不含有子组件的结点,而Composite是含有子组件的类。

Composite模式的典型结构图为：
 

以《大话设计模式》的Composite公司管理例子来实现，分公司需要与总公司一样被对待，同样具备HR部门和财务部门。其实现代码如下：
//Component.h
#ifndef _COMPONENT_H_
#define _COMPONENT_H_

// 公司
class Company
{
public:
    Company();
    virtual ~Company();
public:
    virtual void Operation() = 0;
    virtual void Add(Company* );
    virtual void Remove(Company* );
    virtual Company* GetChild(int );
protected:
private:
};

#endif //~_COMPONENT_H_

//Component.cpp
#include "Component.h"
Company::Company()
{
}
Company::~Company()
{
}
void Company::Add(Company*)
{
}
Company* Company::GetChild(int)
{
    return 0;
}
void Company::Remove(Company*)
{
}

//Composite.h
#ifndef _COMPOSITE_H_
#define _COMPOSITE_H_
#include "Component.h"
#include <vector>
using namespace std;

// 具体的公司
class ConcreteCompany : public Company
{
public:
    ConcreteCompany();
    ~ConcreteCompany();
public:
    void Operation();
    void Add(Company* com);
    void Remove(Company* com);
    Company* GetChild(int index);
protected:
private:
    vector<Company*> comVec;
};

#endif //~_COMPOSITE_H_

//Composite.cpp
#include "Composite.h"
#include "Component.h"
#define NULL 0 //define NULL POINTOR
ConcreteCompany::ConcreteCompany()
{
}
ConcreteCompany::~ConcreteCompany()
{
}
void ConcreteCompany::Operation()
{
    vector<Company*>::iterator comIter = comVec.begin();
    for (;comIter != comVec.end();comIter++)
    {
        (*comIter)->Operation();
    }
}
void ConcreteCompany::Add(Company* com)
{
    comVec.push_back(com);
}
void ConcreteCompany::Remove(Company* com)
{
    comVec.erase(&com);
}
Company* ConcreteCompany::GetChild(int index)
{
    return comVec[index];
}

//Leaf.h
#ifndef _LEAF_H_
#define _LEAF_H_
#include "Component.h"

// 具体的部门--HR
class HRDepartment : public Company
{
public:
    HRDepartment();
    ~HRDepartment();
    void Operation();
protected:
private:
};

// 具体的部门--财务
class FinaceDepartment : public Company
{
public:
    FinaceDepartment();
    ~FinaceDepartment();
    void Operation();
protected:
private:
};

#endif //~_LEAF_H_

//Leaf.cpp
#include "Leaf.h"
#include <iostream>
using namespace std;

HRDepartment::HRDepartment()
{
}
HRDepartment::~HRDepartment()
{
}
void HRDepartment::Operation()
{
    cout<<"HRDepartment::Operation....."<<endl;
}

FinaceDepartment::FinaceDepartment()
{
}
FinaceDepartment::~FinaceDepartment()
{
}
void FinaceDepartment::Operation()
{
    cout<<"FinaceDepartment::Operation....."<<endl;
}

 

//main.cpp
#include "Component.h"
#include "Composite.h"
#include "Leaf.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{
    // HR部门
    HRDepartment* hr = new HRDepartment();
    hr->Operation();

    // 财务部门
    FinaceDepartment* fi = new FinaceDepartment();
    fi->Operation();

    // 具体的分公司
    Company* com = new ConcreteCompany();
    com->Add(hr);
    com->Add(fi);
    com->Operation();

    // 具体的总公司
    Company* com1 = new ConcreteCompany();
    com1->Add(hr);
    com1->Add(fi);
    com1->Add(com);
    com1->Operation();

    // 总公司的下属机构
    Company* ll = com1->GetChild(0);
    ll->Operation();

    return 0;
}

Composite模式通过和Decorator模式有着类似的结构图，但是Composite模式旨在构造类，而Decorator模式重在不生成子类即可给对象添加职责。Decorator模式重在修饰，而Composite模式重在表示。