设计模式 - 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

 

 

 

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  }

 

 

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  }

 

 

 

转载于:https://www.cnblogs.com/whiteyun/archive/2010/12/01/1893173.html