设计模式（六）：组合模式(Composite)

参考书籍：《设计模式 - 可复用面向对象软件的基础》GoF

参考链接：

目录

1.介绍/作用：

2.应用场景：

3.UML类图

4.实现代码

5.扩展/补充

1.介绍/作用：

将对象组合成树形结构以表示“部分 -整体”的层次结构。C o m p o s i t e使得用户对单个对象

和组合对象的使用具有一致性。

2.应用场景：

在绘图编辑器和图形捕捉系统这样的图形应用程序中，用户可以使用简单的组件创建复

杂的图表。用户可以组合多个简单组件以形成一些较大的组件，这些组件又可以组合成更大

的组件。一个简单的实现方法是为 Te x t和L i n e这样的图元定义一些类，另外定义一些类作为这

些图元的容器类( C o n t a i n e r )。

然而这种方法存在一个问题：使用这些类的代码必须区别对待图元对象与容器对象，而

实际上大多数情况下用户认为它们是一样的。对这些类区别使用，使得程序更加复杂。

C o m p o s i t e模式描述了如何使用递归组合，使得用户不必对这些类进行区别，如下图所示。



下图是一个典型的由递归组合的G r a p h i c对象组成的组合对象结构。



3.UML类图



典型的Composite对象结构如下图：





4.实现代码

#ifndef _COMPOSITE_H_
#define _COMPOSITE_H_

#include <iostream>
#include <list>
using namespace std;

//父类
class Component
{
public:
Component(){};
virtual ~Component(){}

virtual void Operation() { cout << "Component Operation" << endl; };
virtual void Add(Component*) {};
virtual void Remove(Component*) {};
virtual Component* GetChild(int){ return nullptr; };
private:

};
//组合子类
class Composite :public Component
{
public:
Composite(){};
virtual ~Composite()
{
cout << "释放list的堆内存" << endl;
for each (Component* var in ComponentList)//释放list的堆内存
{
if (var)
{
delete var;
var = nullptr;

}
}
}

virtual void Operation()
{
cout << "Composite Operation" << endl;
for each (Component* var in ComponentList)//释放list的堆内存
{
var->Operation();
}
}
virtual void Add(Component* pComponent)
{
ComponentList.push_back(pComponent);
}
virtual void Remove(Component* pComponent)
{
ComponentList.remove(pComponent);
}
virtual Component* GetChild(int nPos)
{
list<Component*>::iterator iter = ComponentList.begin();
while ((--nPos) > 0)
iter++;
return 	*iter;

}
private:
list<Component*>  ComponentList;
};
//实现功能的子类:A,B...
class LeafA :public Component
{
public:
LeafA(){};
virtual ~LeafA(){};
virtual void Operation()
{
cout << "LeafA Operation" << endl;
}

private:

};
class LeafB :public Component
{
public:
LeafB(){};
virtual ~LeafB(){};
virtual void Operation()
{
cout << "LeafB Operation" << endl;
}

private:

};

#endif

LeafB* pLeafB1 = new LeafB();
LeafB* pLeafB2 = new LeafB();
LeafB* pLeafB3 = new LeafB();
LeafA* pLeafA1 = new LeafA();
LeafA* pLeafA2 = new LeafA();

//第一个组合
Composite* pComposite = new Composite();
pComposite->Add(pLeafB1);
pComposite->Add(pLeafB2);
pComposite->Add(pLeafB3);
pComposite->Add(pLeafA1);
pComposite->Add(pLeafA2);

//另一个组合
LeafB* pLeafB4 = new LeafB();
LeafA* pLeafA3 = new LeafA();
Composite* pComposite2 = new Composite();
pComposite2->Add(pLeafB4);
pComposite2->Add(pLeafA3);
//将组合加入组合
pComposite2->Add(pComposite);

//operataion
pComposite2->Operation();

if (pComposite)
{
delete pComposite;
pComposite = nullptr;
}
return 0;

输出：

Composite Operation
LeafB Operation
LeafA Operation
Composite Operation
LeafB Operation
LeafB Operation
LeafB Operation
LeafA Operation
LeafA Operation
释放list的堆内存
请按任意键继续. . .
5.扩展/补充