Head First设计模式C++实现--第九章：迭代器(Template)模式

第九章：迭代器(Template)

一、问题的提出

现在有两个菜单（早餐和中餐），其实现方式各不相同：一个用数组，一个用vector（书上用java的ArrayList，但是c++没有，用vector代替！）

#ifndef ITERATOR__H
#define ITERATOR__H
#include <string>
#include <iostream>
#include <vector>
using namespace std;
//定义菜单项
class MenuItem
{
public:
	string name;		//菜名
	string description;	//菜的介绍
	bool vegetarian;	//是否是素
	double price;		//价格

	MenuItem();
	MenuItem(string name, string description, bool vegetarian, double price);//构造函数，初始化菜单项
	string getName();
	string getDescription();
	double getPrice();
	bool isVegetrian();
};
//早餐菜单
class PancakeHouseMenu
{
public:
	vector<MenuItem> menuitems;//使用vector存储菜单项

	PancakeHouseMenu();
	void addItem(string name, string description, bool vegetarian, double price);//添加菜单项
	vector<MenuItem> getMenuItems();//返回菜单项列表
};
//中餐菜单
#define MAX_ITEMS 6		//数组菜单默认大小设为6
class DinerMenu
{
public:
	int size;	//菜单数目
	MenuItem menuItems[MAX_ITEMS];//使用数组保存菜单项

	DinerMenu();
	void addItem(string name, string description, bool vegetarian, double price);//添加菜单项
	MenuItem* getMenuItems();//返回菜单数组
};

#endif

菜单类的实现：

#include "iterator.h"
MenuItem::MenuItem(string name, string description, bool vegetarian, double price)
{
	this->name = name;
	this->description = description;
	this->vegetarian = vegetarian;
	this->price = price;
}
MenuItem::MenuItem(){};//由于数组是静态定义，因此会调用MenuItem的默认构造函数

string MenuItem::getDescription()	{	return description;	}
string MenuItem::getName()			{   return name;		}
double MenuItem::getPrice()			{   return price;		}
bool   MenuItem::isVegetrian()		{   return vegetarian;	}

//早餐菜单操作实现
PancakeHouseMenu::PancakeHouseMenu()
{
	//默认添加一些菜单项
	addItem("Breakfast_1", "Description_1", true, 2.99);
	addItem("Breakfast_2", "Description_2", false, 2.99);
	addItem("Breakfast_3", "Description_3", true, 3.49);
	addItem("Breakfast_4", "Description_4", true, 3.59);
}

void PancakeHouseMenu::addItem(string name, string description, bool vegetarian, double price)
{
	MenuItem item(name, description, vegetarian, price);//新建菜单项
	menuitems.push_back(item);//加入菜单
}

vector<MenuItem> PancakeHouseMenu::getMenuItems()
{
	return menuitems;
}

//中餐菜单操作实现
DinerMenu::DinerMenu()
{
	//默认添加一些菜单项
	addItem("Dinner_1", "Description_Dinner_1", true, 2.99);
	addItem("Dinner_2", "Description_Dinner_2", false, 2.99);
	addItem("Dinner_3", "Description_Dinner_3", false, 3.29);
	addItem("Dinner_4", "Description_Dinner_4", false, 3.05);
}

void DinerMenu::addItem(string name, string description, bool vegetarian, double price)
{
	MenuItem item(name, description, vegetarian, price);//新建菜单项
	if(this->size >= MAX_ITEMS)
		cout<<"Sorry, menu is full!Can't add item to menu"<<endl;
	else
		menuItems[size++] = item;
}

MenuItem* DinerMenu::getMenuItems()
{
	return menuItems;
}

现在的问题是：有两种不同的菜单表现方式，这会带来什么问题？？？

问题：现在要求打印每份菜单上的所有项，各自的实现方式：

<span style="white-space:pre">	</span>PancakeHouseMenu breakfastMenu;
	vector<MenuItem> breakfastItems = breakfastMenu.getMenuItems();
	for(vector<MenuItem>::iterator it=breakfastItems.begin(); it!=breakfastItems.end(); ++it)
	{
		...
	}

	//打印中餐菜单
	DinerMenu dinerMenu;
	for(int i=0; i<dinerMenu.size; i++)
	{
		...
	}

如果我们能够找出一个方法，让他们的菜单项实现一个相同的接口，这样就好了。

二、迭代器模式

1、封装遍历

一直以来，我们都是在学习如何封装变化的部分。很明显，在这发生变化的是：由不同的集合类型所造成的遍历。

现在我们创建一个对象，将它称为迭代器（Iterator），利用它来封装“遍历集合内的每个对象的过程”。

<span style="white-space:pre">	</span>Iterator it = breakfastMenu.createIterator();//取得菜单项迭代器
	while(it.hasNext())//还有其他项
	{
		MenuItem menuItem = it.next();//取得下一项（客户调用hasNext()和next()，而迭代器会暗中调用vector的方法获取值）
	}

	it = dinerMenu.createIterator();
	while(it.hasNext())
	{
		MenuItem menuItem = it.next();//取得下一项（客户调用hasNext()和next()，而迭代器会暗中调用数组下标来取值）
	}

由上面的两种遍历，他们所调用的接口完全一样（都是hasNext()和next()）。这正是一种设计模式，称为迭代器模式（Iterator Pattern）。关于迭代器模式，你所需要知道的第一件事，就是它依赖于一个名为迭代器的接口。这是一个可能的迭代器接口：

class Iterator
{
public:
	virtual bool hasNext() = 0;
	virtual MenuItem next() = 0;
};

现在，一旦有了这个接口，就可以为各种对象集合实现迭代器：数组、列表、散列表。。。如果想要为数组实现迭代器，看起来像这样：

现在实现一个具体的迭代器：

//抽象迭代器
class Iterator
{
public:
	virtual bool hasNext() = 0;
	virtual MenuItem next() = 0;
};
//具体迭代器
class DinerMenuIterator : public Iterator
{
public:
	int position;//position记录当前数组遍历的位置
	MenuItem* menuItems;

	DinerMenuIterator(MenuItem items[]);
	bool hasNext();
	MenuItem next();
};

具体迭代器实现：

DinerMenuIterator::DinerMenuIterator(MenuItem items[])
{
	this->menuItems = items;
}

MenuItem DinerMenuIterator::next()
{
	return menuItems[position++];//next方法返回数组的下一项，并递增位置
}

bool DinerMenuIterator::hasNext()
{
	if(position>=MAX_ITEMS)
		return false;
	return true;
}

同理，可以实现早餐迭代器及其菜单。

2、定义

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

如果有一个统一的方法访问聚合中的每个对象，就可以编写多态的代码和这些聚合搭配。迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象。这不仅让聚合的接口和实现变得更简洁，也可以让聚合更专注在它所应该专注的事情上面（也就是管理对象集合），而不必去理会遍历的事情。