迭代器模式

理论

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

 迭代器模式的应用场景：

　　1. 当需要访问一个聚类对象，而且不管这些对象是什么都需要遍历的时候

　　2. 需要对聚类有多种方式遍历的时候

迭代器模式的优点：

迭代器模式分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不不暴露集合的内部结构，又可让外部代码透明地访问集合内部地数据。

实例

模拟公交车上收取车费的情况，按次序遍历收取车费

代码实现

#include <iostream>
#include <vector>
#include<string>
using namespace std;

//迭代器抽象类
class Iterator {
public:
	virtual string First() = 0;
	virtual string Next() = 0;
	virtual bool IsDone() = 0;
	virtual string CurrentItem() = 0;
};

//聚集抽象类
class Aggregate {
public:
	virtual Iterator* CreateIterator() = 0;
};

class ConcreteAggregate;

//具体迭代器类
class ConcreteIterator :public Iterator {
public:
	ConcreteIterator(ConcreteAggregate* aggregate);
	string First();
	string Next();
	bool IsDone();
	string CurrentItem();

private:
	ConcreteAggregate* aggregate;
	int current;
};

//具体聚集类
class ConcreteAggregate :public Aggregate {
public:
	ConcreteAggregate() {
		items = new vector<string>();
	}
	virtual Iterator* CreateIterator() {
		return new ConcreteIterator(this);
	}
	int Count() {
		return items->size();
	}
	string GetElement(int index) {
		return items->at(index);
	}
	void SetElement(int index, string object) {
		items->push_back(object);
		//items->at(index) = object;
	}

private:
	vector<string>* items;
};

ConcreteIterator::ConcreteIterator(ConcreteAggregate* aggregate) {
	this->aggregate = aggregate;
	this->current = 0;
}
string ConcreteIterator::First() {
	return aggregate->GetElement(0);
}
string ConcreteIterator::Next() {
	current++;
	if (current < aggregate->Count()) {
		return aggregate->GetElement(current);
	}
}
bool ConcreteIterator::IsDone() {
	return current >= aggregate->Count() ? true : false;
}
string ConcreteIterator::CurrentItem() {
	return aggregate->GetElement(current);
}

//反向迭代器
class ConcreteIteratorDesc :public Iterator {
public:
	ConcreteIteratorDesc(ConcreteAggregate* aggregate) {
		this->aggregate = aggregate;
		this->current = aggregate->Count() - 1;
	}
	string First() {
		return aggregate->GetElement(aggregate->Count() - 1);
	}
	string Next() {
		current--;
		if (current > 0) {
			return aggregate->GetElement(current);
		}
	}
	bool IsDone() {
		return current < 0 ? true : false;
	}
	string CurrentItem() {
		return aggregate->GetElement(current);
	}

private:
	ConcreteAggregate* aggregate;
	int current;
};

int main()
{
	ConcreteAggregate* a = new ConcreteAggregate();
	a->SetElement(0, "peopleA");
	a->SetElement(1, "peopleB");
	a->SetElement(2, "peopleC");
	a->SetElement(3, "peopleD");

	Iterator* it = a->CreateIterator();
	string item1 = it->First();
	while (!it->IsDone())
	{
		cout << it->CurrentItem() << " 请买车票" << endl;
		it->Next();
	}

	cout << "--------------------" << endl;

	Iterator* i = new ConcreteIteratorDesc(a);
	string item2 = i->First();
	while (!i->IsDone())
	{
		cout << i->CurrentItem() << " 请买车票" << endl;
		i->Next();
	}

	system("pause");
	return 0;
}