C++设计模式-Composite组合模式

Composite组合模式
作用：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。

UML图如下：

在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是含有子组件的类.

举一个例子来说明这个模式，在UI的设计中,最基本的控件是诸如Button、Edit这样的控件，相当于是这里的Leaf组件，而比较复杂的控件 比如Panel则可也看做是由这些基本的组件组合起来的控件，相当于这里的Composite，它们之间有一些行为含义是相同的，比如在控件上作一个点 击,移动操作等等的，这些都可以定义为抽象基类中的接口虚函数，由各个派生类去实现之，这些都会有的行为就是这里的Operation函数，而添加、删除 等进行组件组合的操作只有非叶子结点才可能有，所以虚拟基类中只是提供接口而且默认的实现是什么都不做。

代码如下：

Composite.h

 1 #ifndef _COMPOSITE_H_  2 #define _COMPOSITE_H_  3  4 #include   5  6 using namespace std;  7  8 /*  9 Component抽象基类，
为组合中的对象声明接口,声明了类共有接口的缺省行为
(如这里的Add,Remove,GetChild函数), 10 声明一个接口函数可以访问Component的子组件. 11 */ 12 class Component 13 { 14 public: 15 //纯虚函数，只提供接口，没有默认的实现 16 virtual void Operation()=0; 17  18 // 虚函数,提供接口,有默认的实现就是什么都不做 19 virtual void Add(Component*);  20 virtual void Remove(Component*); 21 virtual Component* GetChild(int index); 22 virtual ~Component(); 23 protected:  24  Component(); 25 }; 26 27 //Leaf是叶子结点,也就是不含有子组件的结点类，所以不用实现Add、
Remove、GetChild等方法 28 class Leaf:public Component 29 { 30 public:  31 //只实现Operation接口 32 virtual void Operation(); 33  Leaf(); 34 ~Leaf(); 35 }; 36 37 //Composite：含有子组件的类  38 class Composite:public Component  39 { 40 public: 41  Composite();  42 ~Composite(); 43 //实现所有接口  44 void Operation(); 45 void Add(Component*); 46 void Remove(Component*); 47 Component* GetChild(int index); 48 private: 49 //这里采用vector来保存子组件 50 vector m_ComVec;  51 }; 52 #endif

Compostie.cpp

 1 #include "Composite.h"  2 #include   3  4 using namespace std;  5  6 Component::Component()  7 {}  8  9 Component::~Component() 10 {} 11 12 void Component::Add(Component* com) 13 { 14 cout << "add" << endl; 15 } 16 17 void Component::Remove(Component* com) 18 { 19 } 20 21 void Component::Operation() 22 { 23 cout << "Component::Operation" << endl; 24 } 25 26 Component* Component::GetChild(int index) 27 { 28 return NULL; 29 } 30 31 32 Leaf::Leaf() 33 {} 34 35 Leaf::~Leaf() 36 {} 37 38 void Leaf::Operation() 39 { 40 cout<< "Leaf::Operation" <<endl; 41 } 42 43 Composite::Composite() 44 { 45 } 46 47 Composite::~Composite() 48 {} 49 50 void Composite::Add(Component* com) 51 { 52 this->m_ComVec.push_back(com); 53 } 54 55 void Composite::Remove(Component* com) 56 { 57 this->m_ComVec.erase(&com); 58 } 59 60 void Composite::Operation() 61 { 62 cout << "Composite::Operation" << endl; 63 vector::iterator iter = this->m_ComVec.begin(); 64 for(;iter!= this->m_ComVec.end();iter++) 65  { 66 (*iter)->Operation(); 67  } 68 } 69 70 Component* Composite::GetChild(int index) 71 { 72 if(index < 0 || index > this->m_ComVec.size()) 73  { 74 return NULL; 75  } 76 return this->m_ComVec[index]; 77 }

main.cpp

 1 #include "Composite.h"  2 #include   3  4 using namespace std;  5  6 int main()  7 {  8 /*  9  不管是叶子Leaf还是Composite对象pRoot、pCom都实现了Operation接口，所以可以一致对待，直接调用Operation() 10  体现了“使得用户对单个对象和组合对象的使用具有一致性。” 11 */ 12 Composite* pRoot = new Composite(); 13 14 //组合对象添加叶子节点 15 pRoot->Add(new Leaf()); 16 17 Leaf* pLeaf1 = new Leaf(); 18 Leaf* pLeaf2 = new Leaf(); 19 20 //这里的叶子再添加叶子是没有意义的。 21 //由于叶子与组合对象继承了相同的接口，所以语法上是对的，实际上什么也没做(继承自基类Component的Add方法)。 22 //叶子节点只实现了Operation方法，其他Add、Remove、GetChild都继承自基类，没有实际意义。 23 pLeaf1->Add(pLeaf2); 24 pLeaf1->Remove(pLeaf2); 25 //执行叶子Operation操作 26 pLeaf1->Operation(); 27 28 //组合对象实现了基类Component的所有接口，所以可以做各种操作(Add、Remove、GetChild、Operation)。 29 Composite* pCom = new Composite(); 30 //组合对象添加叶子节点 31 pCom->Add(pLeaf1); 32 //组合对象添加叶子节点 33 pCom->Add(pLeaf2); 34 //执行组合对象Operation操作 35 pCom->Operation(); 36 37 //组合对象添加组合对象 38 pRoot->Add(pCom); 39 40 //执行组合对象Operation操作 41 pRoot->Operation(); 42 43 //Component* cp = pCom->GetChild(0); 44 //cp->Operation(); 45 46 //pCom->Remove(pLeaf1); 47 48 return 0; 49 }

组合的另一个例子：摘自http://blog.csdn.net/wuzhekai1985/article/details/6667564

      DP书上给出的定义：将对象组合成树形结构以表示“部分-整体”的层次结构。组合使得用户对单个对象和组合对象的使用具有一致性。注意两个字“树形”。这 种树形结构在现实生活中随处可见，比如一个集团公司，它有一个母公司，下设很多家子公司。不管是母公司还是子公司，都有各自直属的财务部、人力资源部、销 售部等。对于母公司来说，不论是子公司，还是直属的财务部、人力资源部，都是它的部门。整个公司的部门拓扑图就是一个树形结构。

      下面给出组合模式的UML图。从图中可以看到，FinanceDepartment、HRDepartment两个类作为叶结点，因此没有定义添加函数。 而ConcreteCompany类可以作为中间结点，所以可以有添加函数。那么怎么添加呢？这个类中定义了一个链表，用来放添加的元素。

相应的代码实现为：

 1 class Company  2 {  3 public:  4 Company(string name) { m_name = name; }  5 virtual ~Company(){}  6 virtual void Add(Company *pCom){}  7 virtual void Show(int depth) {}  8 protected:  9 string m_name; 10 }; 11 //具体公司 12 class ConcreteCompany : public Company 13 { 14 public: 15 ConcreteCompany(string name): Company(name) {} 16 virtual ~ConcreteCompany() {} 17 void Add(Company *pCom) { m_listCompany.push_back(pCom); } //位于树的中间，可以增加子树 18 void Show(int depth) 19  { 20 for(int i = 0;i < depth; i++) 21 cout<<"-"; 22 cout<endl; 23 list::iterator iter=m_listCompany.begin(); 24 for(; iter != m_listCompany.end(); iter++) //显示下层结点 25 (*iter)->Show(depth + 2); 26  } 27 private: 28 list m_listCompany; 29 }; 30 //具体的部门，财务部 31 class FinanceDepartment : public Company 32 { 33 public: 34 FinanceDepartment(string name):Company(name){} 35 virtual ~FinanceDepartment() {} 36 virtual void Show(int depth) //只需显示，无限添加函数，因为已是叶结点 37  { 38 for(int i = 0; i < depth; i++) 39 cout<<"-"; 40 cout<endl; 41  } 42 }; 43 //具体的部门，人力资源部 44 class HRDepartment :public Company 45 { 46 public: 47 HRDepartment(string name):Company(name){} 48 virtual ~HRDepartment() {} 49 virtual void Show(int depth) //只需显示，无限添加函数，因为已是叶结点 50  { 51 for(int i = 0; i < depth; i++) 52 cout<<"-"; 53 cout<endl; 54  } 55 };

客户使用方式：

 1 int main()  2 {  3 Company *root = new ConcreteCompany("总公司");  4 Company *leaf1=new FinanceDepartment("财务部");  5 Company *leaf2=new HRDepartment("人力资源部");  6 root->Add(leaf1);  7 root->Add(leaf2);  8  9 //分公司A 10 Company *mid1 = new ConcreteCompany("分公司A"); 11 Company *leaf3=new FinanceDepartment("财务部"); 12 Company *leaf4=new HRDepartment("人力资源部"); 13 mid1->Add(leaf3); 14 mid1->Add(leaf4); 15 root->Add(mid1); 16 //分公司B 17 Company *mid2=new ConcreteCompany("分公司B"); 18 FinanceDepartment *leaf5=new FinanceDepartment("财务部"); 19 HRDepartment *leaf6=new HRDepartment("人力资源部"); 20 mid2->Add(leaf5); 21 mid2->Add(leaf6); 22 root->Add(mid2); 23 root->Show(0); 24 25  delete leaf1; delete leaf2; 26  delete leaf3; delete leaf4; 27  delete leaf5; delete leaf6; 28  delete mid1; delete mid2; 29  delete root; 30 return 0; 31 }

上面的实现方式有缺点，就是内存的释放不好，需要客户自己动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。 因为所有的指针都是存在ConcreteCompany类的链表中。C++的麻烦，没有垃圾回收机制。上面的实现方式有缺点，就是内存的释放不好，需要客 户自己动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。因为所有的指针都是存在ConcreteCompany类 的链表中。C++的麻烦，没有垃圾回收机制。