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

时间 2019-12-12

原文原文链接

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

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模式是为解决组件之间的递归组合提供了解决的办法，它主要分为两个派生类：post

1)、Leaf是叶子结点,也就是不含有子组件的结点this

2)、Composite是含有子组件的类.spa

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

代码以下：设计

Composite.h指针

 1 #ifndef _COMPOSITE_H_
 2 #define _COMPOSITE_H_
 3 
 4 #include <vector>
 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<Component*> m_ComVec;        
51 };
52 #endif

Compostie.cppcode

 1 #include "Composite.h"
 2 #include <iostream>
 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<Component*>::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 <iostream>
 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<<m_name<<endl;
23         list<Company *>::iterator iter=m_listCompany.begin();
24         for(; iter != m_listCompany.end(); iter++) //显示下层结点
25             (*iter)->Show(depth + 2);
26     }
27 private:
28     list<Company *> 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<<m_name<<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<<m_name<<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++的麻烦，没有垃圾回收机制。