第20章迭代器模式

一 概念

• 迭代器模式，提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
• 当你需要访问一个对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑使用迭代器模式。

二 UML图

• Iterator 迭代抽象类，用于定义得到开始对象，得到下一个对象，判断是否到结尾，当前对象等抽象方法，统一接口。
• Aggregate 聚合的抽象类
• ConcreteAggregate 具体聚合类，继承Aggregate
• ConcreteIterator 具体迭代器类，继承Iterator，实现开始，下一个，是否结尾，当前对象等方法

三 C++代码实现
lesson1.h

#ifndef LESSON1_H
#define LESSON1_H
#pragma once
#include <iostream>
#include <string>
#include <list>
#include <vector>
using namespace std;

class ConcreteAggregate;

typedef string object;
//迭代抽象类，用于定义得到开始对象，得到下一个对象，判断是否到结尾
//当前对象等抽象方法，统一接口
class Iterator
{
public:
	virtual object First() = 0;
	virtual object Next() = 0;
	virtual object CurrentItem() = 0;
	virtual bool IsDone() = 0;
};
//Aggregate聚集抽象类
class Aggregate
{
public:
	virtual Iterator* CreateIterator() = 0;
	virtual Iterator* CreateIteratorDesc() = 0;
	virtual vector<object>* GetVector() = 0;
};

//实现从前向后的迭代器
class ConcreteIterator : public Iterator
{
public:
	//初始化时将具体的聚合对象传入
	ConcreteIterator(Aggregate* aggregate);
	object First() override;
	object Next() override;
	object CurrentItem() override;
	bool IsDone() override;
private:
	ConcreteAggregate* m_aggregate;  //定义了一个具体聚集对象
	int current;
};
//实现从后向前的具体迭代器类
class ConcreteIteratorDesc : public Iterator
{
public:
	//初始化时将具体的聚合对象传入
	ConcreteIteratorDesc(Aggregate* aggregate);
	object First() override;
	object Next() override;
	object CurrentItem() override;
	bool IsDone() override;
private:
	ConcreteAggregate* m_aggregate; 
	int current;
};

//定义一个具体的聚合类
class ConcreteAggregate : public Aggregate
{
public:
	ConcreteAggregate();
	~ConcreteAggregate();
	Iterator* CreateIterator() override;
	Iterator* CreateIteratorDesc() override;
	int GetCount() const;
	vector<object>* GetVector() override;
	object GetElement(int index);
private:
	vector<object>* items;
};
#endif // LESSON1_H

lesson1.cpp

#include "lesson1.h"

//初始化时将具体的聚合对象传入
ConcreteIterator::ConcreteIterator(Aggregate* aggregate)
{
	this->m_aggregate = (ConcreteAggregate*)aggregate;
	this->current = 0;
}

object ConcreteIterator::First()
{
	return this->m_aggregate->GetVector()->at(0);
}

object ConcreteIterator::Next()
{
	this->current++;
	if (this->current < this->m_aggregate->GetCount())
	{
		return this->m_aggregate->GetVector()->at(this->current);
	}
}
object ConcreteIterator::CurrentItem()
{
	return this->m_aggregate->GetVector()->at(this->current);
}
bool ConcreteIterator::IsDone()
{
	return this->current >= this->m_aggregate->GetVector()->size() ? true : false;
}


ConcreteAggregate::ConcreteAggregate()
{
	items = new vector<object>;
}
ConcreteAggregate::~ConcreteAggregate()
{
	delete items;
}


Iterator* ConcreteAggregate::CreateIterator()
{
	return new ConcreteIterator(this);
}
Iterator* ConcreteAggregate::CreateIteratorDesc()
{
	return new ConcreteIteratorDesc(this);
}
int ConcreteAggregate::GetCount() const
{
	return items->size();
}
vector<object>* ConcreteAggregate::GetVector()
{
	return this->items;
}
object ConcreteAggregate::GetElement(int index)
{
	return items->at(index);
}

ConcreteIteratorDesc::ConcreteIteratorDesc(Aggregate * aggregate)
{
	this->m_aggregate = (ConcreteAggregate*)aggregate;
	this->current = this->m_aggregate->GetVector()->size() - 1;
}

object ConcreteIteratorDesc::First()
{

	return this->m_aggregate->GetVector()->at(this->m_aggregate->GetVector()->size() - 1);
}

object ConcreteIteratorDesc::Next()
{
	this->current--;
	if (this->current >= 0)
	{
		return this->m_aggregate->GetVector()->at(this->current);
	}
}

object ConcreteIteratorDesc::CurrentItem()
{
	return this->m_aggregate->GetVector()->at(this->current);
}

bool ConcreteIteratorDesc::IsDone()
{
	return this->current < 0 ? true : false;
}

ConsoleApplication1.cpp

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include "lesson1.h"
using namespace std;

int main()
{
	ConcreteAggregate* bus = new ConcreteAggregate();  //公交车对象
	bus->GetVector()->push_back("大鸟");
	bus->GetVector()->push_back("小菜");
	bus->GetVector()->push_back("行李");
	bus->GetVector()->push_back("老外");
	bus->GetVector()->push_back("公交内部人员");
	bus->GetVector()->push_back("小偷");

	//产生从前向后的迭代器
	Iterator* it1 = bus->CreateIterator();

	while (!it1->IsDone())
	{
		cout << it1->CurrentItem() << " 请买车票" << endl;
		it1->Next();
	}

	cout << "
从后向前的遍历
" << endl;

	//产生从后向前的迭代器
	Iterator* it2 = bus->CreateIteratorDesc();

	while (!it2->IsDone())
	{
		cout << it2->CurrentItem() << "请买车票" << endl;
		it2->Next();
	}

	return 0;
}

运行结果

参考资料
1 《大话设计模式C++实现-第20章-迭代器模式》https://blog.csdn.net/xiqingnian/article/details/42089611