设计模式——迭代器模式_Iterator Pattern

迭代器模式：

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.(它提供一种方法访问一个容器对象中各个元素，而又不需要该对象的内部细节

C++代码实现

#ifndef __AGGREGATE__H__
#define __AGGREGATE__H__


#include "Iterator.h"
#include <string>
using namespace std;

class Aggregate {
public:
	virtual Iterator* CreateIterator() = 0;
	virtual Aggregate* GetItem(int index) = 0;
	virtual int GetSize() = 0;
	virtual void AddItem(string str) = 0;
	virtual void Operation() = 0;
};

class ConcreteAggregate : public Aggregate {
public:
	ConcreteAggregate(string str):_str(str) { }
	virtual ~ConcreteAggregate();
	Iterator* CreateIterator();
	Aggregate* GetItem(int index);
	int GetSize();
	void AddItem(string str);
	void Operation();

private:
	string _str;
	vector<Aggregate*> _obj;
};

#endif

#ifndef __ITERATOR__H__
#define __ITERATOR__H__

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


class Aggregate;

class Iterator {
public:
	virtual void Next() = 0;
	virtual bool hasNext() = 0;
	virtual Aggregate* CurrentItem() = 0;

protected:
	Iterator() { }
};

class ConcreteIterator : public Iterator {
public:
	ConcreteIterator(vector<Aggregate*> obj);

	void Next(); 
	bool hasNext();
	Aggregate* CurrentItem();

private:
	vector<Aggregate*> _obj;
	int _currItem;
};


#endif

#include "Aggregate.h"
#include "Iterator.h"

ConcreteAggregate::~ConcreteAggregate() {
	typedef std::vector<Aggregate*>::iterator AG_ITER;
	for (AG_ITER iter = _obj.begin(); iter!=_obj.end(); ++iter) {
		if (*iter != NULL) {
			Aggregate* pTmp = *iter;
			delete pTmp;
		}

	}
}

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

Aggregate*  ConcreteAggregate::GetItem(int index) {
	if (index < GetSize())
		return _obj[index];
	return NULL;
}

int  ConcreteAggregate::GetSize() { 
	return _obj.size(); 
}


void ConcreteAggregate::AddItem(string str) {
	Aggregate* pNew = new ConcreteAggregate(str);
	_obj.push_back(pNew);
}


void ConcreteAggregate::Operation() {
	cout << "ConcreteAggregate::Operation() ---> " << _str << endl; 
}

#include "Iterator.h"
#include "Aggregate.h"

ConcreteIterator::ConcreteIterator(vector<Aggregate*> obj):_obj(obj), _currItem(0) { }

void ConcreteIterator::Next() {
	if (_currItem < _obj.size())
		_currItem++;
}

bool ConcreteIterator::hasNext() {
	if (_currItem < _obj.size())
		return true;
	return false;
}

Aggregate* ConcreteIterator::CurrentItem() {
	return _obj[_currItem];
}

#include "Iterator.h"
#include "Aggregate.h"

int main()
{
	Aggregate* pNoumenon = new ConcreteAggregate(string("test1"));
	
	pNoumenon->AddItem(string("test2"));
	pNoumenon->AddItem(string("test3"));
	pNoumenon->AddItem(string("test4"));
	pNoumenon->AddItem(string("test5"));

	Iterator* pConcreteIterator = pNoumenon->CreateIterator();
	while (pConcreteIterator->hasNext()){
		Aggregate* pItem = pConcreteIterator->CurrentItem();
		pItem->Operation();
		pConcreteIterator->Next();
	}
	delete pConcreteIterator;
	delete pNoumenon;
	return 0;
}