设计模式之组合模式（composite）

概述

组合模式有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

生活中的例子

组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。让用户一致地使用单个对象和组合对象。虽然例子抽象一些，但是算术表 达式确实是组合的例子。算术表达式包括操作数、操作符和另一个操作数。操作数可以是数字，也可以是另一个表达式。这样，2+3和（2+3）+（4*6）都 是合法的表达式。（来自http://blog.163.com/renjianqin_1984/blog/static/1328821542010720104922316/）

在上面的图中，Component是组合和个体的基类，单个对象成了Leaf，而组合对象就是Composite，他们同时具有父类的操作。因此在客户看来他们是一致的。这样的话我们可以在Composite下再可以添加Composite对象或者Leaf对象，如此递归成了树形结构。

再来个例子（来自大话设计模式）



/*

    有一家公司，总公司在北京，在上海有其在华东地区的分公司，然后在南京和杭州分别有各自的办事处。这里每个地方无论是总部还是分部都会有相同的部门设置，所以可以用Composite模式解决。

/*

#include<iostream>
#include<string>
#include<vector>
using namespace std;

class Company
{
protected:
string cname;
public:
Company(string name):cname(name)
{
}
virtual void Add(Company *c)=0;//增加
virtual void Remove(Company *c)=0;//删除
virtual void Display(int depth)=0;//显示
virtual void LineOfDuty()=0;//职责
};

//具体公司
class ConcreteCompany:public Company
{
private:
vector<Company*> children;
public:
ConcreteCompany(string name):Company(name)
{
}
void Add(Company *c)
{
children.push_back(c);
}
void Remove(Company *c)
{
children.erase(&c);
}
void Display(int depth)
{
string s(depth,'-');
cout<<s<<cname<<endl;
vector<Company*>::iterator iter;
for(iter=children.begin();iter!=children.end();iter++)
{
(*iter)->Display(depth+2);
}
}
void LineOfDuty()
{
vector<Company*>::iterator iter;
for(iter=children.begin();iter!=children.end();++iter)
{
(*iter)->LineOfDuty();
}
}
};

//人事部
class HRDepartment:public Company
{
private:
vector<Company*> children;
public:
HRDepartment(string name):Company(name)
{
}
void Add(Company *c)
{
children.push_back(c);
}
void Remove(Company *c)
{
children.erase(&c);
}
void Display(int depth)
{
string s(depth,'-');
cout<<s<<cname<<endl;
}
void LineOfDuty()
{
cout<<cname<<"\t员工招聘培训管理"<<endl;
}
};

//财务部
class FinanceDepartment:public Company
{
private:
vector<Company*> children;
public:
FinanceDepartment(string name):Company(name)
{
}
void Add(Company *c)
{
children.push_back(c);
}
void Remove(Company *c)
{
children.erase(&c);
}
void Display(int depth)
{
string s(depth,'-');
cout<<s<<cname<<endl;
}
void LineOfDuty()
{
cout<<cname<<"\t公司财务收支管理"<<endl;
}
};

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

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

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

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

cout<<"结构图："<<endl;
c->Display(1);
cout<<endl;
cout<<"职责:"<<endl;
c->LineOfDuty();

return 0;

}

运行结果：



这就是一个树形结构，子节点都可以跟父节点一样拥有相同的职能，但是他们所处的层次却是清晰地分开了，这就是Composite模式的好处。

注：组合模式一种继承关系，派生类中含有包含基类指针的容器。

组合模式和其他相关模式

1)装饰模式（Decorator模式）经常与Composite模式一起使用。当装饰和组合一起使用时，它们

通常有一个公共的父类。因此装饰必须支持具有 Add、Remove和GetChild 操作的Component接口。

2）Flyweight模式让你共享组件，但不再能引用他们的父部件。

3）（迭代器模式）Itertor可用来遍历Composite。

4）（观察者模式）Visitor将本来应该分布在Composite和L e a f类中的操作和行为局部化。