“设计模式”学习之四：组合（结构型）与迭代器（行为型）

一、组合（Composite）
1、引言
看看树形结构，一些结点是叶结点（没有子结点），另一些可能还有子结点。组合模式用于构造这种基本对象和组合对象的“部分-整体”层次结构。其中，基本对象可以被组合成组合对象，而组合对象可以被递归组合成更复杂的组合对象。而对于基本对象和组合对象，用户可以一致使用。

2、一般思路
下图中，Leaf类中的int _numLeaf; 成员变量是为了区分实例化第几个基本对象（功能详见下节代码实例）。
Composite类中的vector <Component *>_comVector;用以存贮子部件，也可用Array、List、树、hash表等数据结构。
Composite::Operation()中将引入迭代器，用以遍历子部件。而Add/Remove/GetChild()都是为了管理子部件。



3、典型代码
依据上图类关系，编写简单实例完整代码如下：

// composite.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <vector>
#include <iostream>
#include <conio.h>
using namespace std;

class Component
{
public:
Component(){}
virtual ~Component(){}
virtual void Operation() = 0;//遍历子部件
virtual void Add(Component*){}//管理子部件
virtual void Remove(Component*){}//管理
virtual Component* GetChild(int index){return 0;}//获取某个子部件
};

class Leaf : public Component
{
public:
Leaf(int numLeaf){_numLeaf = numLeaf;}
~Leaf(){}
void Operation(){cout<< "Leaf "<<_numLeaf<<" operation..."<<endl;}
int _numLeaf;//为了区分是第几个基本对象
};

class Composite : public Component
{
public:
vector <Component *>_comVector;//以存贮子部件，也可用Array、List、树、hash表等数据结构
Composite(){}
~Composite(){}
Component* GetChild(int index){return _comVector[index];}
void Operation()
{
//引入迭代器实现按顺序访问子部件
vector <Component *>:: iterator _comIterator = _comVector.begin();
for (; _comIterator != _comVector.end(); _comIterator++)
{
(*_comIterator) -> Operation();
}
}
void Add(Component* com)
{
_comVector.push_back(com);
}
void Remove(Component* com)
{
//		_comVector.erase(&com);
}

};
int _tmain(int argc, _TCHAR* argv[])
{
Leaf * aLeaf0 = new Leaf(0);
Leaf * aLeaf1 = new Leaf(1);

Composite *aComposite = new Composite();
aComposite->Add(aLeaf0);
aComposite->Add(aLeaf1);
aComposite->Operation();//内部实现遍历
cout<<endl;

Component	*aComponent = aComposite->GetChild(0);
aComponent->Operation();
aComponent = aComposite->GetChild(1);
aComponent->Operation();

_getch();/*等待按键继续*/
return 0;
}

代码运行情况如下：



4、应用提示
（1）共享组件可以节约存贮，享元Flyweight模式可以奏效。
（2）Composite可以用多种数据结构存贮子部件。当然，也可以应用解释器Interpreter模式，使用变量对应各节点，从而不用使用通用数据结构。

（3）组合经常和装饰者一块用，此时，装饰父类也必须声明Add/Remove/GetChild操作。
（4）组合模式是用“单一责任”设计原则来获取透明性——客户对叶节点与组合一视同仁，这样会损失部分操作“安全性”，比如需要警惕叶节点不能执行Add。

二、迭代器（Iterator，别名“游标”Cursor）
1、引言
对于一个聚合对象（如List、vector、自定义的组合类等等），如果想遍历其内部各个元素，又不暴露其内部结构，抑或需要不同的方式遍历它，甚至可能需要同时进行多个遍历。可以将对它的遍历访问功能抽离出来，封装到迭代器中。

2、一般思路
图中给出了迭代器Iterator的最小接口：First、Next、IsDone、CurrentItem四个。
Aggregate类即是需要迭代遍历的聚合类。



3、典型代码
////////////////////////////////////////////////

// "Iterator.h"
//
#ifndef _ITERATOR_H_
#define _ITERATOR_H_

typedef int Object;
class Iterator;

class Aggregate
{
public:
Aggregate(){}
virtual ~Aggregate(){}
virtual Iterator* CreateIterator() = 0;
virtual Object GetItem(int)=0;
virtual int GetSize()=0;
};

class ConcreteAggregate : public Aggregate
{
const static int SIZE = 5;
Object _object[SIZE];

public:
ConcreteAggregate()
{
for(int i=0; i<SIZE; i++)
_object[i] = i;
}
~ConcreteAggregate(){}
Iterator* CreateIterator();
Object GetItem(int index)
{
if(index < this->GetSize())
return _object[index];
else
return -1;
}
int GetSize(){return SIZE;}
};

class Iterator
{
public:
Iterator(){}
virtual ~Iterator(){}
virtual void First() = 0;
virtual void Next() = 0;
virtual bool IsDone() = 0;
virtual Object CurrentItem() = 0;
};

class ConcreteIterator : public Iterator
{
public:
Aggregate * _aggregate;
int _index;

ConcreteIterator(Aggregate *aggregate, int index=2)
{
//假设默然从第三个聚合对象开始索引
this->_aggregate = aggregate;
this->_index = index;
}
virtual ~ConcreteIterator(){}

void First()
{
_index = 0;
}
void Next()
{
if(_index < _aggregate->GetSize())
_index++;
}
bool IsDone()
{
return (_index == _aggregate->GetSize());
}
Object CurrentItem()
{
return _aggregate->GetItem(_index);
}
};

#endif //~_ITERATOR_H_

////////////////////////////////////////////////

// Iterator.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <conio.h>
#include "Iterator.h"

using namespace std;

Iterator* ConcreteAggregate::CreateIterator()
{
return new ConcreteIterator(this);
}

int _tmain(int argc, _TCHAR* argv[])
{
Aggregate * aAggregate = new ConcreteAggregate();
//	Iterator *aIterator = new ConcreteIterator(aAggregate);
Iterator *aIterator = aAggregate->CreateIterator();//工厂方法

aIterator->First();//从第一个聚合对象开始索引
for(; !aIterator->IsDone(); aIterator->Next())
cout<<aIterator->CurrentItem()<<endl;

_getch();/*等待按键继续*/
return 0;
}

输出情况如下图：若无“aIterator->First();”，则输出为“2 3 4”。（从第三个聚合对象开始）



4、应用提示
（1）如果需要针对不同的聚合对象动态创建不同的迭代器，需要Factory Method模式。
（2）迭代器常常在其内部存储一个备忘录Memento用以捕获一个迭代状态。
（3）在C++标准模板库STL中，迭代器是容器container
（包括：向量vector、双端队列deque、表list、队列queue、堆栈stack、集合set、多重集合multiset、映射map、多重映射multimap）和算法（有大约100个实现算法的模版函数，功能涉及比较、交换、查找、遍历、复制、修改、移除、反转、排序、合并等等）的黏合剂。
（4）空迭代器NullIterator用于处理边界条件，它总是表明已经完成了遍历，通过IsDone()中返回true，或者hasNext()返回false。
附：STL学习资料
关于STL的介绍：点击打开链接
百度百科：点击打开链接
《Effective STL》Scott Meyers著，50条有效使用STL的经验。
《STL源码剖析》侯捷著，挖掘STL内部机理。