设计模式之实现迭代器模式

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

baseobject.h

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "CIterator.h"
#define MAX_ARRAY_SIZE 100
using namespace std;

//前置定义
class CIteratorInterface;
class CElectricIterator;

//////////////////////////////////////////
//在C++对象不像在Java中一样，有统一的基类Ojbect,
//所以，我们在这里为所有要出售的对象设定一个对象的基类
class CBaseObjectMenuItem
{
private:
 string m_Name;
 float  m_Price;
public:
 CBaseObjectMenuItem(string name, float price) : m_Name(name), m_Price(price){}

 virtual float getPrice() {
  return m_Price;
 }
 
 virtual string getName(){
  return m_Name;
 }

 void showInformation(){
  cout<<"Name : "<<m_Name<<"\t\t\t";
  cout<<"Price : "<<m_Price<<endl;
 }
};

////////////////////////////////////////////
//我这里先给出一个菜单类的接口，
//这里简单处理菜单项，假设菜单项总是由一个名字和一个价格所决定的
class CSaleMenu
{
public:
 virtual void addMenuItem(string Name, float Price) = 0;

 virtual CIteratorInterface* createIterator() = 0;
};

/////////////////////////////////////////
//电器菜单类，用数组实现
//其中有一个方法可以用来创建一个迭代器
class CElectricMenu : public CSaleMenu
{
private:
 unsigned long       m_totalItems;

 //我这里也用指针的原因是为了防止对象切片(slicing)
 //因为现在这里还是非常简单的情况就是，菜单对像还只是一个基类的直接对象
 //如果这个对象是一个菜单项基类的派生类的对象时，切记：千万不要以数组的多态方式来处理
 //这样会导致切片问题，可详见more efficient C++的相关章节
 CBaseObjectMenuItem* m_ItemPointers[MAX_ARRAY_SIZE];

public:
 CElectricMenu() : m_totalItems(0){}

 void addMenuItem(string Name, float Price){
  m_ItemPointers[m_totalItems++] = new CBaseObjectMenuItem(Name, Price);
 }

 inline unsigned long getTotalMenuItems(){
  return m_totalItems;
 }

 CBaseObjectMenuItem** getMenu(){
  return m_ItemPointers;
 }

 CIteratorInterface* createIterator();

 ~CElectricMenu(){
  for(unsigned long i = 0; i < m_totalItems; i++)
   delete m_ItemPointers[i];
 }
};

/////////////////////////////////////////
//食品菜单菜，用vector实现
class CFoodMenu : public CSaleMenu
{
private:
 //我这里也用指针的原因是为了防止对象切片(slicing)
 //因为现在这里还是非常简单的情况就是，菜单对像还只是一个基类的直接对象
 //如果这个对象是一个菜单项基类的派生类的对象时，切记：千万不要以数组的多态方式来处理
 //这样会导致切片问题，可详见more efficient C++的相关章节
 vector<CBaseObjectMenuItem*> m_ItemPointer;
public:
 void addMenuItem(string Name, float Price){
  m_ItemPointer.push_back(new CBaseObjectMenuItem(Name, Price));
 }

 vector<CBaseObjectMenuItem*>& getMenu(){
  return m_ItemPointer;
 }

 CIteratorInterface* createIterator();

 ~CFoodMenu(){
  for(int i = 0; i < static_cast<int>(m_ItemPointer.size()); i++){
   delete m_ItemPointer[i];
  }
  m_ItemPointer.clear();
 }
};

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

CIterator.h

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "baseobject.h"
using namespace std;

class CBaseObjectMenuItem;

//////////////////////////////////////////
//迭代器的接口，这是每个迭代器都要实现的．
class CIteratorInterface
{
public:
 virtual bool hasNext() = 0;
 virtual CBaseObjectMenuItem* next() = 0;

 virtual ~CIteratorInterface() {}
};

/////////////////////////////////////////
//这是一个用于数组接口的迭代器，我们实现了电器数组的迭代
//用数据实现
class CElectricIterator : public CIteratorInterface
{
private:
 unsigned long m_totalItems;
 CBaseObjectMenuItem** m_MenuItem;

 unsigned long m_currentIt;

public:
 CElectricIterator(CBaseObjectMenuItem** inMenu, unsigned long inTI);

 bool hasNext();

 CBaseObjectMenuItem* next();
};

/////////////////////////////////////////
//这是一个用于vector接口的迭代器，我们实现了食物vector的迭代
//用vector实现
class CFoodIterator : public CIteratorInterface
{
private:
 vector<CBaseObjectMenuItem*>& m_MenuItem;

 unsigned long m_currentIt;
public:
 CFoodIterator(vector<CBaseObjectMenuItem*>& inItemList);

 bool hasNext();

 CBaseObjectMenuItem* next();
};

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

CMenuShower.h

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

#pragma once
#include <iostream>
#include "baseobject.h"
#include "CIterator.h"

//////////////////////////////////////////////
//是时候来做一个显然菜单的类的
//这个类是与具体菜单元素存放方式无关的（已经解耦了）
//当要具体类时，就创建一个iterator，切记，用完后要删除
class CMenuShower
{
private:
 CSaleMenu* m_Menu1; //电子产品类的menu
 CSaleMenu* m_Menu2; //食品类的menu

 //可以像下面这样来管理所有菜单项
 //vector<CSaleMenu*> m_Menus;

public:
 CMenuShower(CSaleMenu* inElecMenu, CSaleMenu* inFoodMenu) :
 m_Menu1(inElecMenu), m_Menu2(inFoodMenu)
 {

 }

private:
 static void PrintSingleIterator(CIteratorInterface* it){
  if(!it)
   return;
  while(it->hasNext()){
   CBaseObjectMenuItem* tmp = it->next();
   tmp->showInformation();
  }
 }

public:

 //哈哈。这下总算是成功与菜单实现解耦了。
 //如果没有解耦的话，我们还需要知道不同人实现的放在数据的方法，然后分别处理。
 //在使用了迭代器模式后，我们就需要知道迭代器模式的接品即可。
 void PrintAllMenuItems(){
  //电器类商品，　“电器类菜单说：　你打印吧，不要管我是怎么实现的”
  cout<<"[电器类商品]"<<endl;
  PrintSingleMenu(m_Menu1);

  //食物类商品 “食物类菜单说：　你打印吧，你也不要管我是怎么实现的”
  cout<<"[食物类商品]"<<endl;
  PrintSingleMenu(m_Menu2);
 }

public:
 static void PrintSingleMenu(CSaleMenu* menu)
 {
  if(!menu)
   return;
  CIteratorInterface* it = menu->createIterator();
  PrintSingleIterator(it);
  delete it;
 }
};

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

baseobject.cpp

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

#include "baseobject.h"
#include "CIterator.h"

CIteratorInterface* CElectricMenu::createIterator()
{
 //注意这里new了一个iterator
 //在调用的地方，调用完了之后，一定要把这块内存释放掉。
 return static_cast<CIteratorInterface*>(
  new CElectricIterator(m_ItemPointers, m_totalItems));
}

CIteratorInterface* CFoodMenu::createIterator()
{
 //注意这里new了一个iterator
 //在调用的地方，调用完了之后，一定要把这块内存释放掉。
 return static_cast<CIteratorInterface*>(
  new CFoodIterator(m_ItemPointer));
}

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

Citerator.cpp

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

#include "CIterator.h"
#include "baseobject.h"

/////////////////////////////////////////
//这是一个用于数组接口的迭代器，我们实现了电器数组的迭代
//用数据实现
//实现部分
CElectricIterator::CElectricIterator(CBaseObjectMenuItem** inMenu, unsigned long inTI)
: m_MenuItem(inMenu), m_totalItems(inTI), m_currentIt(0){

}

bool CElectricIterator::hasNext()
{
 return m_currentIt < m_totalItems ? true : false;
}

CBaseObjectMenuItem* CElectricIterator::next(){
 if(m_currentIt < m_totalItems)
  return m_MenuItem[m_currentIt++];
 return NULL;
}

/////////////////////////////////////////
//这是一个用于vector接口的迭代器，我们实现了食物vector的迭代
//用vector实现
//实现部分
CFoodIterator::CFoodIterator(vector<CBaseObjectMenuItem*>& inItemList)
: m_MenuItem(inItemList), m_currentIt(0){

}

bool CFoodIterator::hasNext()
{
 return m_currentIt < m_MenuItem.size() ? true : false;
}

CBaseObjectMenuItem* CFoodIterator::next(){
 if(m_currentIt < m_MenuItem.size())
  return m_MenuItem[m_currentIt++];
 return NULL;
}

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

testiteratorPattern.cpp

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

/*
 设计模式：　迭代器模式

 提供一种方法顺序访问一个聚合对象的各个元素 
 首先，迭代器这个方法根本不管聚合究竟是由数组还是由Array或者Vector来保存的．
 其次，迭代器模式把在元素之间遍历的责任交给迭代器，而不是某种特殊的聚合对象．

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
这个程序运用迭代器模式来遍历一些菜单项
在程序里有两个菜单项，
　　一个是电子产品的菜单项  用数据实现
  　一个是食品的菜单项      用vector实现

现在有一个终端机，并不知道两个菜单项的内在数据的具体存储和实现方式，但需要给客户显现数据的内容．
所以，我在这里使用了迭代器模式，把迭代过程进行封装．

CIterator为迭代器的基类

在这个迭代器模式的例子中Menu子类的createIterator()是这个模式的精髓。
这个成员返回一个所有封装的迭代器的基类接口.所以使用者就不必要去关心返回的
迭代器的内部数据存储方式
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

by 何戬, hejian@cad.zju.edu.cn
*/
#include <iostream>
#include "CMenuShower.h"
using namespace std;

int main()
{
 CElectricMenu* elecMenu = new CElectricMenu();
 elecMenu->addMenuItem("诺基亚E71", 2300.0f);
 elecMenu->addMenuItem("诺基亚N29", 2120.0f);
 CFoodMenu*     foodMenu = new CFoodMenu;
 foodMenu->addMenuItem("KFC全家套餐", 66.0f);
 foodMenu->addMenuItem("原味吮指鸡块", 7.5f);

 CMenuShower* ms = new CMenuShower(elecMenu, foodMenu);
 ms->PrintAllMenuItems();

 delete foodMenu;
 delete elecMenu;

 return 0;
}