组合(Composite)模式：将对象以树形结构组织起来，以达成“部分----整体"的层次结构，使得客户端对单个对象和组合对象的使用具有一致性。
组成：
1抽象构件角色(Component):它为组合中的对象声明接口，也可以为共有接口实现缺省行为。
2树叶构件角色（Leaf）:在组合中表示叶节点对象---没有子节点，实现抽象构件角色声明的接口。
3树枝构件角色(Composite)：在组合中表示分支节点对象----有子节点，实现抽象构件角色声明的接口：存储子部件。
//组合中的抽象基类
class Component
{
public：
Component(){}
virtual ~Component(){}
//纯虚函数提供接口
virtual void Openration() = 0;
// 虚函数,提供接口,有默认的实现就是什么都不做
virtual void Add(Component * pChild)
{}
virtual void Remove(Component * pChild)
{}
virtual Component * GetChile(int nIndex)
{return NULL;}
};
// 派生自Component,是其中的叶子组件的基类
class Leaf:public Component{
public:
Leaf(){}
virtual ~Leaf(){}
virtual void Operation(){
std::cout << "Operation by leaf\n";
}
};
// 派生自Component,是其中的含有子件的组件的基类
class Composite:public Component{
private:
 // 采用list容器去保存子组件
 std::list<Component*> m_ListOfComponent;

public:
 Composite(){}
 virtual ~Composite()
{
//清list
}

   virtual void Operation()
{
  for (list<Component*>::iterator it = m_ListOfComponent.begin();
        it != m_ListOfComponent.end();
        ++it)
{
    (*it)->Operation();
}
}

 virtual void Add(Component* pChild)
{
   m_ListOfComponent.push_back(pChild);
}
 virtual void Remove(Component* pChild)
{

std::list<Component*>::iterator iter;

 iter = find(m_ListOfComponent.begin(), m_ListOfComponent.end(), pChild);

 if (m_ListOfComponent.end() != iter)
 {
  m_ListOfComponent.erase(iter);
 }
}
 virtual Component* GetChild(int nIndex)
{
   

if (nIndex <= 0 || nIndex > m_ListOfComponent.size())
  return NULL;

 std::list<Component*>::iterator iter1, iter2;
 int i;
 for (i = 1, iter1  = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
  iter1 != iter2;
  ++iter1, ++i)
 {
  if (i == nIndex)
   break;
 }

 return *iter1;
}
};

void main()
{
 

Leaf *pLeaf1 = new Leaf();
 Leaf *pLeaf2 = new Leaf();

 Composite* pComposite = new Composite;
 pComposite->Add(pLeaf1);
 pComposite->Add(pLeaf2);
 pComposite->Operation();
 pComposite->GetChild(2)->Operation();
delete pComposite;
}
//组合模式 就像树一样 有多个叶子 叶子实现树干（抽象基类）的一个接口，树枝用来串树叶，把树叶弄到一起，即可以使用单个对象的接口方法，又可以使用组合对象的方法。有点懂了 嘿嘿