迭代器模式（Iterator 模式）

背景 在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明的访问其中包含的元素，同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作提供了可能。使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“应对变化中的集合对象”提供了一种优雅的方式。 方法 提供一种方法顺序访问一个聚合对象中的各个元素，又不暴露（稳定）该对象的内部表示。 迭代特点 迭代抽象：访问一个聚合对象的内容不用暴露其内部表示。 迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。 缺点 从迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构会导致问题。

//Aggregate.h
#pragma once
class Iterator;
class Aggregate {
          
   
public:
	virtual Iterator* NewConcreteIterator() = 0;
	virtual int GetElement(int index) = 0;
	virtual int GetSize() = 0;
	virtual ~Aggregate();
protected:
	Aggregate();
};
class ConcreteAggregate :public Aggregate {
          
   
public:
	enum {
          
    size = 10 };
	ConcreteAggregate();
	~ConcreteAggregate();
	Iterator* NewConcreteIterator();
	int GetElement(int index);
	int GetSize();
private:
	int elements[size];
};
//Aggregate.cpp
#include"Aggregate.h"
#include"Iterator.h"
Aggregate::Aggregate() {
          
   

}
Aggregate::~Aggregate() {
          
   

}
ConcreteAggregate::ConcreteAggregate() {
          
   
	for (int i = 0; i < size; i++) {
          
   
		elements[i] = i;
	}
}
ConcreteAggregate::~ConcreteAggregate() {
          
   
	
}
Iterator* ConcreteAggregate::NewConcreteIterator() {
          
   
	return new ConcreteIterator(this);
}
int ConcreteAggregate::GetElement(int index) {
          
   
	if (index < size) {
          
   
		return elements[index];
	}
	return -1;
}
int ConcreteAggregate::GetSize() {
          
   
	return size;
}
//Iterator.h
#pragma once
class Aggregate;
class Iterator {
          
   
public:
	virtual ~Iterator();
	virtual void First() = 0;
	virtual void Next() = 0;
	virtual bool IsDone() = 0;
	virtual int CurrentElement() = 0;
protected:
	Iterator();
};
class ConcreteIterator :public Iterator {
          
   
public:
	ConcreteIterator(Aggregate* aggregate, int index = 0);
	~ConcreteIterator();
	void First();
	void Next();
	bool IsDone();
	int CurrentElement();
private:
	int index;
	Aggregate* aggregate;
};
//Iterator.cpp
#include"Iterator.h"
#include"Aggregate.h"
Iterator::Iterator() {
          
   

}
Iterator::~Iterator() {
          
   

}
ConcreteIterator::ConcreteIterator(Aggregate* aggregate, int index) {
          
   
	this->aggregate = aggregate;
	this->index = index;
}
ConcreteIterator::~ConcreteIterator() {
          
   

}
void ConcreteIterator::First() {
          
   
	this->index = 0;
}
void ConcreteIterator::Next() {
          
   
	if (index < aggregate->GetSize()) {
          
   
		index++;
	}
}
bool ConcreteIterator::IsDone() {
          
   
	return index == aggregate->GetSize();
}
int ConcreteIterator::CurrentElement() {
          
   
	return aggregate->GetElement(index);
}
//Main.cpp
#include"Aggregate.h"
#include"Iterator.h"
#include<iostream>
using namespace std;
int main() {
          
   
	Aggregate* aggregate = new ConcreteAggregate();
	Iterator* iterator = new ConcreteIterator(aggregate);
	for (; !(iterator->IsDone()); iterator->Next()) {
          
   
		cout << iterator->CurrentElement() << endl;
	}
	delete iterator;
	delete aggregate;
}

运行结果