设计模式 - Composite模式（组合模式）
Composite的作用：
将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。Composite比较容易理解，想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。所以Composite模式使用到Iterator模式，和Chain of Responsibility模式类似。
Composite好处：
1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2.更容易在组合体内加入对象部件，客户端不必因为加入了新的对象部件而更改代码。
如何使用Composite?
首先定义一个接口或抽象类，这是设计模式通用方式了，其他设计模式对接口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和管理Composite组合体的对象们（或称部件Component）。
抽象基类：
1)Component:为组合中的对象声明接口,声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数),声明一个接口函数可以访问Component的子组件。
接口函数：
1)Component::Operatation:定义了各个组件共有的行为接口,由各个组件的具体实现。
2)Component::Add添加一个子组件
3)Component::Remove::删除一个子组件
4)Component::GetChild:获得子组件的指针
解析：
Component模式是为解决组件之间的递归组合提供了解决的办法,它主要分为两个派生类,其中的Leaf是叶子结点,也就是不含有子组件的结点,而Composite是含有子组件的类.举一个例子来说明这个模式,在UI的设计中,最基本的控件是诸如Button,Edit这样的控件,相当于是这里的Leaf组件,而比较复杂的控件比如List则可也看做是由这些基本的组件组合起来的控件,相当于这里的Composite,它们之间有一些行为含义是相同的,比如在控件上作一个点击,移动操作等等的,这些都可以定义为抽象基类中的接口虚函数,由各个派生类去实现之,这些都会有的行为就是这里的Operation函数,而添加,删除等进行组件组合的操作只有非叶子结点才可能有,所以虚拟基类中只是提供接口而且默认的实现是什么都不做。
代码实现：
Composite.h
1 #ifndef COMPOSITE_H
2 #define COMPOSITE_H
3
4 #include <list>
5
6 // 组合中的抽象基类
7 class Component
8 {
9 public:
10 Component(){}
11 virtual ~Component(){}
12
13 // 纯虚函数,只提供接口,没有默认的实现
14 virtual void Operation() = 0;
15
16 // 虚函数,提供接口,有默认的实现就是什么都不做
17 virtual void Add(Component* pChild);
18 virtual void Remove(Component* pChild);
19 virtual Component* GetChild(int nIndex);
20 };
21
22 // 派生自Component,是其中的叶子组件的基类
23 class Leaf
24 : public Component
25 {
26 public:
27 Leaf(){}
28 virtual ~Leaf(){}
29
30 virtual void Operation();
31 };
32
33 // 派生自Component,是其中的含有子件的组件的基类
34 class Composite
35 : public Component
36 {
37 public:
38 Composite(){}
39 virtual ~Composite();
40
41 virtual void Operation();
42
43 virtual void Add(Component* pChild);
44 virtual void Remove(Component* pChild);
45 virtual Component* GetChild(int nIndex);
46
47 private:
48 // 采用list容器去保存子组件
49 std::list<Component*> m_ListOfComponent;
50 };
51
52 #endif
2 #define COMPOSITE_H
3
4 #include <list>
5
6 // 组合中的抽象基类
7 class Component
8 {
9 public:
10 Component(){}
11 virtual ~Component(){}
12
13 // 纯虚函数,只提供接口,没有默认的实现
14 virtual void Operation() = 0;
15
16 // 虚函数,提供接口,有默认的实现就是什么都不做
17 virtual void Add(Component* pChild);
18 virtual void Remove(Component* pChild);
19 virtual Component* GetChild(int nIndex);
20 };
21
22 // 派生自Component,是其中的叶子组件的基类
23 class Leaf
24 : public Component
25 {
26 public:
27 Leaf(){}
28 virtual ~Leaf(){}
29
30 virtual void Operation();
31 };
32
33 // 派生自Component,是其中的含有子件的组件的基类
34 class Composite
35 : public Component
36 {
37 public:
38 Composite(){}
39 virtual ~Composite();
40
41 virtual void Operation();
42
43 virtual void Add(Component* pChild);
44 virtual void Remove(Component* pChild);
45 virtual Component* GetChild(int nIndex);
46
47 private:
48 // 采用list容器去保存子组件
49 std::list<Component*> m_ListOfComponent;
50 };
51
52 #endif
Composite.cpp 1
2 #include "Composite.h"
3 #include <iostream>
4 #include <algorithm>
5
6 /*-------------------------------------------------------------------
7 Component成员函数的实现
8
9 -------------------------------------------------------------------*/
10 void Component::Add(Component* pChild)
11 {
12
13 }
14
15 void Component::Remove(Component* pChild)
16 {
17
18 }
19
20 Component* Component::GetChild(int nIndex)
21 {
22 return NULL;
23 }
24
25 /*-------------------------------------------------------------------
26 Leaf成员函数的实现
27
28 -------------------------------------------------------------------*/
29 void Leaf::Operation()
30 {
31 std::cout << "Operation by leaf\n";
32 }
33
34 /*-------------------------------------------------------------------
35 Composite成员函数的实现
36
37 -------------------------------------------------------------------*/
38 Composite::~Composite()
39 {
40 std::list<Component*>::iterator iter1, iter2, temp;
41
42 for (iter1 = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
43 iter1 != iter2;
44 )
45 {
46 temp = iter1;
47 ++iter1;
48 delete (*temp);
49 }
50 }
51
52 void Composite::Add(Component* pChild)
53 {
54 m_ListOfComponent.push_back(pChild);
55 }
56
57 void Composite::Remove(Component* pChild)
58 {
59 std::list<Component*>::iterator iter;
60
61 iter = find(m_ListOfComponent.begin(), m_ListOfComponent.end(), pChild);
62
63 if (m_ListOfComponent.end() != iter)
64 {
65 m_ListOfComponent.erase(iter);
66 }
67 }
68
69 Component* Composite::GetChild(int nIndex)
70 {
71 if (nIndex <= 0 || nIndex > m_ListOfComponent.size())
72 return NULL;
73
74 std::list<Component*>::iterator iter1, iter2;
75 int i;
76 for (i = 1, iter1 = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
77 iter1 != iter2;
78 ++iter1, ++i)
79 {
80 if (i == nIndex)
81 break;
82 }
83
84 return *iter1;
85 }
86
87 void Composite::Operation()
88 {
89 std::cout << "Operation by Composite\n";
90
91 std::list<Component*>::iterator iter1, iter2;
92
93 for (iter1 = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
94 iter1 != iter2;
95 ++iter1)
96 {
97 (*iter1)->Operation();
98 }
99 }
2 #include "Composite.h"
3 #include <iostream>
4 #include <algorithm>
5
6 /*-------------------------------------------------------------------
7 Component成员函数的实现
8
9 -------------------------------------------------------------------*/
10 void Component::Add(Component* pChild)
11 {
12
13 }
14
15 void Component::Remove(Component* pChild)
16 {
17
18 }
19
20 Component* Component::GetChild(int nIndex)
21 {
22 return NULL;
23 }
24
25 /*-------------------------------------------------------------------
26 Leaf成员函数的实现
27
28 -------------------------------------------------------------------*/
29 void Leaf::Operation()
30 {
31 std::cout << "Operation by leaf\n";
32 }
33
34 /*-------------------------------------------------------------------
35 Composite成员函数的实现
36
37 -------------------------------------------------------------------*/
38 Composite::~Composite()
39 {
40 std::list<Component*>::iterator iter1, iter2, temp;
41
42 for (iter1 = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
43 iter1 != iter2;
44 )
45 {
46 temp = iter1;
47 ++iter1;
48 delete (*temp);
49 }
50 }
51
52 void Composite::Add(Component* pChild)
53 {
54 m_ListOfComponent.push_back(pChild);
55 }
56
57 void Composite::Remove(Component* pChild)
58 {
59 std::list<Component*>::iterator iter;
60
61 iter = find(m_ListOfComponent.begin(), m_ListOfComponent.end(), pChild);
62
63 if (m_ListOfComponent.end() != iter)
64 {
65 m_ListOfComponent.erase(iter);
66 }
67 }
68
69 Component* Composite::GetChild(int nIndex)
70 {
71 if (nIndex <= 0 || nIndex > m_ListOfComponent.size())
72 return NULL;
73
74 std::list<Component*>::iterator iter1, iter2;
75 int i;
76 for (i = 1, iter1 = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
77 iter1 != iter2;
78 ++iter1, ++i)
79 {
80 if (i == nIndex)
81 break;
82 }
83
84 return *iter1;
85 }
86
87 void Composite::Operation()
88 {
89 std::cout << "Operation by Composite\n";
90
91 std::list<Component*>::iterator iter1, iter2;
92
93 for (iter1 = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
94 iter1 != iter2;
95 ++iter1)
96 {
97 (*iter1)->Operation();
98 }
99 }
Main.cpp 1
2 #include "Composite.h"
3 #include <stdlib.h>
4
5 int main()
6 {
7 Leaf *pLeaf1 = new Leaf();
8 Leaf *pLeaf2 = new Leaf();
9
10 Composite* pComposite = new Composite;
11 pComposite->Add(pLeaf1);
12 pComposite->Add(pLeaf2);
13 pComposite->Operation();
14 pComposite->GetChild(2)->Operation();
15
16 delete pComposite;
17
18 system("pause");
19
20 return 0;
21 }
2 #include "Composite.h"
3 #include <stdlib.h>
4
5 int main()
6 {
7 Leaf *pLeaf1 = new Leaf();
8 Leaf *pLeaf2 = new Leaf();
9
10 Composite* pComposite = new Composite;
11 pComposite->Add(pLeaf1);
12 pComposite->Add(pLeaf2);
13 pComposite->Operation();
14 pComposite->GetChild(2)->Operation();
15
16 delete pComposite;
17
18 system("pause");
19
20 return 0;
21 }
