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模式重在表示。