设计模式C++实现（13）——迭代器模式

前置知识：c++模板类，对此不熟悉甚至没听过的同学可以左转c++基础知识

定义：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

前言：学习c++以来，STL的使用贯穿整个程序代码，其中与其密不可分的迭代器也用了很多次了，但往往没有深究它的作用，原理到底是什么，结合这个迭代器模式的学习算是有了一个不错的认知了。

#include <iostream>
#include <vector>

using namespace std;

template<class Item>
class Iterator
{
public:
	Iterator() {};
	virtual ~Iterator() {};

	virtual void first() = 0;
	virtual void next() = 0;
	virtual Item *curItem() = 0;
	virtual bool isDone() = 0;
};


template<class Item>class Aggregate;
template<class Item>
class ConcreteIterator : public Iterator <Item>
{
public:
	ConcreteIterator(Aggregate<Item> *a) :aggr(a), cur(0) {};
	virtual ~ConcreteIterator() {};

	virtual void first();
	virtual void next();
	virtual Item *curItem();
	virtual bool isDone();
private:
	Aggregate<Item> *aggr;
	int cur;
};

template<class Item>
void ConcreteIterator<Item>::first()
{
	cur = 0;
}

template<class Item>
void ConcreteIterator<Item>::next()
{
	if (cur < aggr->getSize())
		cur++;
}

template<class Item>
Item *ConcreteIterator<Item>::curItem()
{
	if (cur < aggr->getSize())
	{
		return &(*aggr)[cur];
	}
	else
	{
		return NULL;
	}
}

template<class Item>
bool ConcreteIterator<Item>::isDone()
{
	return cur >= aggr->getSize();
}


template<class Item>
class Aggregate {
public:
	Aggregate() {};
	virtual ~Aggregate() {};

	virtual void pushData(Item item) = 0;
	virtual Iterator<Item>* createIterator() = 0;
	virtual Item& operator[](int index) = 0;
	virtual int getSize() = 0;
};


template <class Item>
class ConcreteAggregate : public Aggregate<Item>
{
public:
	ConcreteAggregate() {};
	virtual ~ConcreteAggregate() {};

	virtual void pushData(Item item);
	virtual Iterator<Item>* createIterator();
	virtual Item& operator[](int index);
	virtual int getSize();
private:
	vector<Item> data;
};

template <class Item>
void ConcreteAggregate<Item>::pushData(Item item)
{
	data.push_back(item);
}

template <class Item>
Iterator<Item>* ConcreteAggregate<Item>::createIterator()
{
	return new ConcreteIterator<Item>(this);
}

template <class Item>
Item& ConcreteAggregate<Item>::operator[](int index)
{
	return data[index];
}

template <class Item>
int ConcreteAggregate<Item>::getSize()
{
	return data.size();
}

int main(int argc, char *argv[])
{

	Aggregate<int> * aggr = new ConcreteAggregate<int>();
	aggr->pushData(3);
	aggr->pushData(2);
	aggr->pushData(1);
	Iterator<int> * it = aggr->createIterator();

	for (it->first(); !it->isDone(); it->next())
	{
		std::cout << *it->curItem() << std::endl;
	}
	delete it;
	delete aggr;
	system("pause");
	return 0;
}

Iterator: 抽象迭代器 ConcreteIterator: 具体迭代器 Aggregate: 抽象聚合类 ConcreteAggregate: 具体聚合类，只对客户暴露抽象迭代器、抽象聚合类，很有意思的一种模式