首页 > 代码库 > 【设计模式】组合模式
【设计模式】组合模式
1、定义
1.1 标准定义
组合模式(Composite Pattern)也叫合成模式，有时又叫做部分-整体模式（ Part-Whole），主要是用来描述部分与整体的关系，其定义如下：
Compose objects into tree structures to represent part-whole hierarchies.Composite lets clients treat individual objects and compositions of objects uniformly.（将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。）
1.2 通用类图
● Component抽象构件角色
定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性，比如我们例子中的getInfo就封装到了抽象类中。
● Leaf叶子构件
叶子对象，其下再也没有其他的分支， 也就是遍历的最小单位。
● Composite树枝构件
树枝对象，它的作用是组合树枝节点和叶子节点形成一个树形结构。
2、实现
2.1 类图
在Component中声明所有用来管理子对象的方法，其中包括Add、Remove等，这样实现Component接口的所有子类都具备了Add和Remove。这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备 完全一致的行为 接口。但问题也很明显，因为Leaf类本身不具备Add()、Remove()方法的 功能，所以实现它是没有意义的。
抽象基类:
1)Component:为组合中的对象声明接口，声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数)，声明一个接口函数可以访问Component的子组件.
接口函数:
1)、Component::Operatation:定义了各个组件共有的行为接口，由各个组件的具体实现.
2)、Component::Add添加一个子组件
3)、Component::Remove::删除一个子组件.
4)、Component::GetChild:获得子组件的指针.
说明:
Component模式是为解决组件之间的递归组合提供了解决的办法，它主要分为两个派生类：
1)、Leaf是叶子结点,也就是不含有子组件的结点
2)、Composite是含有子组件的类
2.2 代码
2.2.2 组合对象
// Composite.h #ifndef _COMPOSITE_H_ #define _COMPOSITE_H_ #include <vector> using namespace std; /* Component抽象基类，为组合中的对象声明接口,声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数), 声明一个接口函数可以访问Component的子组件. */ class Component { public: //纯虚函数，只提供接口，没有默认的实现 virtual void Operation()=0; // 虚函数,提供接口,有默认的实现就是什么都不做 virtual void Add(Component*); virtual void Remove(Component*); virtual Component* GetChild(int index); virtual ~Component(); protected: Component(); }; //Leaf是叶子结点,也就是不含有子组件的结点类，所以不用实现Add、Remove、GetChild等方法 class Leaf:public Component { public: //只实现Operation接口 virtual void Operation(); Leaf(); ~Leaf(); }; //Composite：含有子组件的类 class Composite:public Component { public: Composite(); ~Composite(); //实现所有接口 void Operation(); void Add(Component*); void Remove(Component*); Component* GetChild(int index); private: //这里采用vector来保存子组件 vector<Component*> m_ComVec; };
#endif
// Compostie.cpp #include "Composite.h" #include <iostream> using namespace std; Component::Component(){} Component::~Component(){} void Component::Add(Component* com) { cout << "add" << endl; } void Component::Remove(Component* com){} void Component::Operation() { cout << "Component::Operation" << endl; } Component* Component::GetChild(int index) { return NULL; } Leaf::Leaf(){} Leaf::~Leaf(){} void Leaf::Operation() { cout<< "Leaf::Operation" <<endl; } Composite::Composite(){} Composite::~Composite(){} void Composite::Add(Component* com) { this->m_ComVec.push_back(com); } void Composite::Remove(Component* com) { this->m_ComVec.erase(&com); } void Composite::Operation() { cout << "Composite::Operation" << endl; vector<Component*>::iterator iter = this->m_ComVec.begin(); for(;iter!= this->m_ComVec.end();iter++) { (*iter)->Operation(); } } Component* Composite::GetChild(int index) { if(index < 0 || index > this->m_ComVec.size()) { return NULL; } return this->m_ComVec[index]; }
2.2.2 调用
// main.cpp #include "Composite.h" #include <iostream> using namespace std; int main() { /* 不管是叶子Leaf还是Composite对象pRoot、pCom都实现了Operation接口，所以可以一致对待，直接调用Operation() 体现了“使得用户对单个对象和组合对象的使用具有一致性。” */ Composite* pRoot = new Composite(); //组合对象添加叶子节点 pRoot->Add(new Leaf()); Leaf* pLeaf1 = new Leaf(); Leaf* pLeaf2 = new Leaf(); //这里的叶子再添加叶子是没有意义的。 //由于叶子与组合对象继承了相同的接口，所以语法上是对的，实际上什么也没做(继承自基类Component的Add方法)。 //叶子节点只实现了Operation方法，其他Add、Remove、GetChild都继承自基类，没有实际意义。 pLeaf1->Add(pLeaf2); pLeaf1->Remove(pLeaf2); //执行叶子Operation操作 pLeaf1->Operation(); //组合对象实现了基类Component的所有接口，所以可以做各种操作(Add、Remove、GetChild、Operation)。 Composite* pCom = new Composite(); //组合对象添加叶子节点 pCom->Add(pLeaf1); //组合对象添加叶子节点 pCom->Add(pLeaf2); //执行组合对象Operation操作 pCom->Operation(); //组合对象添加组合对象 pRoot->Add(pCom); //执行组合对象Operation操作 pRoot->Operation(); return 0; }
3、DP书的实现
3.1 类图
一个集团公司，它有一个母公司，下设很多家子公司。不管是母公司还是子公司，都有各自直属的财务部、人力资源部、销售部等。对于母公司来说，不论是子公司，还是直属的财务部、人力资源部，都是它的部门。整个公司的部门拓扑图就是一个树形结构。
从图中可以看到，FinanceDepartment、HRDepartment两个类作为叶结点，因此没有定义添加函数。而ConcreteCompany类可以作为中间结点，所以可以有添加函数。那么怎么添加呢？这个类中定义了一个链表，用来放添加的元素。
3.2 实现
3.2.1 公司代码
class Company { public: Company(string name) { m_name = name; } virtual ~Company(){} virtual void Add(Company *pCom){} virtual void Show(int depth) {} protected: string m_name; }; //具体公司 class ConcreteCompany : public Company { public: ConcreteCompany(string name): Company(name) {} virtual ~ConcreteCompany() {} void Add(Company *pCom) { m_listCompany.push_back(pCom); } //位于树的中间，可以增加子树 void Show(int depth) { for(int i = 0;i < depth; i++) cout<<"-"; cout<<m_name<<endl; list<Company *>::iterator iter=m_listCompany.begin(); for(; iter != m_listCompany.end(); iter++) //显示下层结点 (*iter)->Show(depth + 2); } private: list<Company *> m_listCompany; }; //具体的部门，财务部 class FinanceDepartment : public Company { public: FinanceDepartment(string name):Company(name){} virtual ~FinanceDepartment() {} virtual void Show(int depth) //只需显示，无限添加函数，因为已是叶结点 { for(int i = 0; i < depth; i++) cout<<"-"; cout<<m_name<<endl; } }; //具体的部门，人力资源部 class HRDepartment :public Company { public: HRDepartment(string name):Company(name){} virtual ~HRDepartment() {} virtual void Show(int depth) //只需显示，无限添加函数，因为已是叶结点 { for(int i = 0; i < depth; i++) cout<<"-"; cout<<m_name<<endl; } };
3.2.2 调用
int main() { Company *root = new ConcreteCompany("总公司"); Company *leaf1=new FinanceDepartment("财务部"); Company *leaf2=new HRDepartment("人力资源部"); root->Add(leaf1); root->Add(leaf2); //分公司A Company *mid1 = new ConcreteCompany("分公司A"); Company *leaf3=new FinanceDepartment("财务部"); Company *leaf4=new HRDepartment("人力资源部"); mid1->Add(leaf3); mid1->Add(leaf4); root->Add(mid1); //分公司B Company *mid2=new ConcreteCompany("分公司B"); FinanceDepartment *leaf5=new FinanceDepartment("财务部"); HRDepartment *leaf6=new HRDepartment("人力资源部"); mid2->Add(leaf5); mid2->Add(leaf6); root->Add(mid2); root->Show(0); delete leaf1; delete leaf2; delete leaf3; delete leaf4; delete leaf5; delete leaf6; delete mid1; delete mid2; delete root; return 0; }
3.2.3 总结
上面的实现方式有缺点，就是内存的释放不好，需要客户自己动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。因为所有的指针都是存在ConcreteCompany类的链表中。C++的麻烦，没有垃圾回收机制。
4、总结
4.1 优点
● 高层模块调用简单
一棵树形机构中的所有节点都是Component， 局部和整体对调用者来说没有任何区别，也就是说， 高层模块不必关心自己处理的是单个对象还是整个组合结构，简化了高层模块的代码。
● 节点自由增加
使用了组合模式后，我们可以看看，如果想增加一个树枝节点、树叶节点是不是都很容易，只要找到它的父节点就成，非常容易扩展，符合开闭原则，对以后的维护非常有利。
4.2 缺点
组合模式有一个非常明显的缺点，看到我们在场景类中的定义，提到树叶和树枝使用时的定义了吗？ 直接使用了实现类！ 这在面向接口编程上是很不恰当的，与依赖倒置原则冲突，读者在使用的时候要考虑清楚，它限制了你接口的影响范围。
4.3 适用场景
当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了,如树形菜单、 文件和文件夹管理。
基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。
用户不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合二写一些选择判断语句，让客户可以一致地使用组合结构和单个对象。
【设计模式】组合模式