将对象组合成树形结构以表示“部分-整体”的层次结构

复合组合模式

功能：将对象组合成树形结构，以表示“整体”分层结构。复合使用户可以在使用单个对象和组合对象时保持一致。

UML图如下：

声明所有用于管理Component中子对象的方法，包括Add，Remove等，以便实现Component接口的所有子类都具有Add和Remove。

这样做的好处是，叶节点和分支节点与外界无法区分，并且它们具有完全一致的行为接口。

但是问题也很明显，因为Leaf类本身不具有Add（）和Remove（）方法的功能，因此实现它毫无意义。

何时使用组合模式：

当您发现需求反映了部分层次结构和整体层次结构，并且希望用户忽略复合对象和单个对象之间的差异，并统一使用复合结构中的所有对象时，应考虑使用复合模式。

基本对象可以组合为更复杂的组合对象，并且可以再次组合此组合对象，以便递归继续进行，并且可以在客户端代码中使用基础对象的任何地方使用组合对象。

用户无需关心他们是在处理叶子节点还是在处理复合组件，也不需要为定义组合二编写一些选择判断语句。

组合模式允许客户一致地使用复合结构和单个对象。

抽象基类：

1)组件：声明组合中对象的接口，声明该类通用接口的默认行为（例如此处的Add，Remove，GetChild函数），并声明一个接口函数以访问组件的子组件。

接口功能：

1) Component :: Operatation：定义每个组件共有的行为接口，该接口由每个组件实现。

2) Component :: Add添加一个子组件

3) Component :: Remove :: Remove一个子组件。

4) Component :: GetChild：获取子组件的指针。

说明：

组件模式是为组件之间的递归组合提供一种解决方案，它主要分为两个派生类别：

1)，Leaf是叶节点，即不包含子组件的节点

2)，Composite是带有子组件的类。

以一个示例来说明此模式。在UI设计中，最基本的控件是诸如Button和Edit之类的控件，它们在这里等效于Leaf组件，而更复杂的控件（例如Panel）也可以视为。由这些基本组件组成的控件在此等效于Composite。它们之间的某些行为和含义是相同的，例如单击控件，移动操作等，可以将其定义为抽象基类。接口的虚拟功能由每个派生类实现。所有这些行为在这里都是Operation函数，而组件组合的添加，删除等操作仅适用于非叶子节点，因此虚拟基类仅提供Interface，默认实现是不执行任何操作。

代码如下：

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://www.pc-fly.com/a/shoujiruanjian/article-377562-1.html