[设计模式]Composite组合模式

问题

在开发中，我们经常可能要递归构建树状的组合结构。

当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与当个对象的不同，统一的使用组合结构中的所有对象时，应该考虑用组合模式。

composite组合模式

将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和组合对象的使用具有一致性。

component部件：为组合中的对象声明接口，声明了类共有接口的缺省行为。声明一个接口函数用于访问和管理Component的子部件

composite组合：定义有枝节点行为，用来存储子部件，在component接口中实现与子部件有关的操作，Add，Remove等

leaf叶子：在组合模式中表示叶节点对象，叶节点没有子节点

Component模式是为解决组件之间的递归组合提供了解决的办法,它主要分为两个派生类,其中的Leaf是叶子结点,也就是不含有子组件的结点,而Composite是含有子组件的类.举一个例子来说明这个模式,在UI的设计中,最基本的控件是诸如Button,Edit这样的控件,相当于是这里的Leaf组件,而比较复杂的控件比如List则可也看做是由这些基本的组件组合起来的控件,相当于这里的Composite,它们之间有一些行为含义是相同的,比如在控件上作一个点击,移动操作等等的,这些都可以定义为抽象基类中的接口虚函数,由各个派生类去实现之,这些都会有的行为就是这里的Operation函数,而添加,删除等进行组件组合的操作只有非叶子结点才可能有,所以虚拟基类中只是提供接口而且默认的实现是什么都不做.

composite组合模式比较容易理解，想到composite组合模式就应该想到树形结构图。组合体内这些对象都有共同接口，当组合体一个对象的方法被调用执行时，composite将遍历(iterator)整个树形结构，寻找同样包含这个方法的对象并调用执行。可以用牵一动百来形容。所以composite组合模式使用到了Iterator模式，和ChainOfResponsibility模式类似。

小demo

composite.h

/********************************************************************
	created:	2006/07/20
	filename: 	Composite.h
	author:		李创
                http://www.cppblog.com/converse/

	purpose:	Composite模式的演示代码
*********************************************************************/

#ifndef COMPOSITE_H
#define COMPOSITE_H
#include <string>
#include <list>
using namespace std;
// 组合中的抽象基类
class Component
{
private:
    string m_strName;
public:
	Component(string paramName){m_strName=paramName;}
	virtual ~Component(){}
    
	// 纯虚函数,只提供接口,没有默认的实现
	virtual void Operation() = 0;

	// 虚函数,提供接口,有默认的实现就是什么都不做
    virtual void Add(Component* pChild){}//添加一个子部件
    virtual void Remove(Component* pChild){}//删除一个子部件
    virtual Component* GetChild(int nIndex){return NULL;}//获取子部件的指针
};

// 派生自Component,是其中的叶子组件的基类
class Leaf  : public Component
{
public:
    Leaf(string strParam):Component(strParam){}
	virtual ~Leaf(){}

	virtual void Operation();
};

// 派生自Component,是其中的含有子件的组件的基类
class Composite	: public Component
{
public:
    Composite(string strParam):Component(strParam){}
	virtual ~Composite();

	virtual void Operation();

	virtual void Add(Component* pChild);
	virtual void Remove(Component* pChild);
	virtual Component* GetChild(int nIndex);

private:
	// 采用list容器去保存子组件
	std::list<Component*>	m_ListOfComponent;
};

#endif

composite.cpp

/********************************************************************
	created:	2006/07/20
	filename: 	Composite.cpp
	author:		李创
                http://www.cppblog.com/converse/

	purpose:	Composite模式的演示代码
*********************************************************************/

#include "Composite.h"
#include <iostream>
#include <algorithm>
  
/*-------------------------------------------------------------------
	Leaf成员函数的实现
-------------------------------------------------------------------*/
void Leaf::Operation()
{
    static int a=0;
    a=a++;
	std::cout << "Operation by leaf\n"<<a<<endl;
}

/*-------------------------------------------------------------------
	Composite成员函数的实现
-------------------------------------------------------------------*/
Composite::~Composite()
{
	std::list<Component*>::iterator iter1, iter2, temp;

	for (iter1  = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
		 iter1 != iter2;
		 )
	{
		temp = iter1;
		++iter1;
		delete (*temp);
	}
}

void Composite::Add(Component* pChild)
{
	m_ListOfComponent.push_back(pChild);
}

void Composite::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);
	}
}

Component* Composite::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 Composite::Operation()
{
	std::cout << "Operation by Composite\n";

	std::list<Component*>::iterator iter1, iter2;

	for (iter1  = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end();
		iter1 != iter2;
		++iter1)
	{
		(*iter1)->Operation();
	}
}

main.cpp

#include "Composite.h"
#include <stdlib.h> 
int main()
{ 
	Composite* pComposite = new Composite("Compostie");
	pComposite->Add(new Leaf("leaf1"));
	pComposite->Add(new Leaf("leaf2"));

	pComposite->Operation();
	pComposite->GetChild(2)->Operation();
    delete pComposite;

    Composite* myComposite = new Composite("myCompostie");
    myComposite->Add(new Leaf("leaf3"));
    delete myComposite;

	system("pause");
	return 0;
}

好处：

1.使客户端调用简单，客户端可以一致的使用组合结构或单个对象，用户就不必关心自己处理的是单个对象还是整个组合结构，这就简化了客户端代码

2.更容易在组合体内加入对象部件。客户端不必因为加入了新的对象部件二更改代码。

如何使用composite？

首先定义一个接口或抽象类，这是设计模式的通用方式，其他设计模式对接口内部定义限制不多，composite却有个规定，那就是要在接口内部定义一个用于访问和管理composite组合体对象们(或称部件component)。