design_pattern_iterator

最新推荐文章于 2019-05-20 10:22:36 发布
最新推荐文章于 2019-05-20 10:22:36 发布
阅读量319 收藏
点赞数
分类专栏： Design Pattern C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhucai4/article/details/44139629
版权

This post implements Iterator Pattern in <Head First Design Patterns>. 


Take traversal-of-a-collection functionality out of the collection and promote it to "full object status". This simplifies the collection, allows many traversals to be active simultaneously, and decouples collection algorithms from collection data structures.

"Every 'container-like' class must have an iterator." It may seem like a violation of encapsulation for a Stack class to allow its users to access its contents directly, but John Lakos' argument is that the designer of a class inevitably leaves something out. Later, when users need additional functionality, if an iterator was originally provided, they can add functionality with "open for extension, closed for modification". Without an iterator, their only recourse is to invasively customize production code. Below, the orginal Stack class did not include an equality operator,but it did include an iterator. As a result, the equality operator could be readily retrofitted.

  1. Design an "iterator" class for the "container" class
  2. Add a createIterator() member to the container class
  3. Clients ask the container object to create an iterator object
  4. Clients use the first(), isDone(), next(), andcurrentItem() protocol

First of all, we define Menu class

class MenuItem {
private:
    std::string name;
	std::string description;
	bool vegetarian;
	double price;

public:
    MenuItem(std::string name, std::string description, bool vegetarian, double price) {
		this->name = name;
		this->description = description;
		this->vegetarian = vegetarian;
		this->price = price;
	}

	virtual std::string getName() { return name; }
	virtual std::string getDescription() { return description; }
	virtual double getPrice() { return price; }
	virtual bool isVegetarian() { return vegetarian; }
	virtual void toString() {
		std::stringstream result (name.c_str());
		result << " $" << price << std::endl << description.c_str();
	}
};

class Menu {
public:
    virtual ~Menu() {}
	virtual Iterator<MenuItem>* createIterator() const = 0;
};

class PancakeHouseMenu : public Menu {
private:
    std::vector<MenuItem*> menuItems;

public:
    PancakeHouseMenu() {
		addItem("K&B's Pancake Breakfast",
			"Pancakes with scrambled eggs, and toast",
			true,
			2.99);

		addItem("Regular Pancake Breakfast",
			"Pancakes with fried eggs, sausage",
			false,
			2.99);

		addItem("Blueberry Pancakes",
			"Pancakes made with fresh blueberries",
			true,
			3.49);

		addItem("Waffles",
			"Waffles, with your choice of blueberries or strawberries",
			true,
			3.59);
	}

	virtual void addItem(std::string name, std::string description, bool vegetarian, double price) {
		MenuItem* menuItem = new MenuItem(name, description, vegetarian, price);
		menuItems.push_back(menuItem);
	}

	virtual std::vector<MenuItem*> getMenuItems() {
		return menuItems;
	}

	virtual Iterator<MenuItem>* createIterator() {
		return dynamic_cast<Iterator<MenuItem>*> (new PancakeHouseMenuIterator(menuItems));
	}

	virtual void toString() {
		std::cout << "Objectville Pancake House Menu" << std::endl;
	}

	// other menu methods here
};

class DinerMenu : public Menu {
private:
    static const int MAX_ITEMS = 6;
	int numberOfItems;
	MenuItem** menuItems;

public:
    DinerMenu() : numberOfItems(0) {
		menuItems = new MenuItem*[MAX_ITEMS + 1];	// added one additional entry;
		for (int i = 0; i <= MAX_ITEMS; i++)		// to hold a null (0) value
			menuItems[i] = 0;						// so hasNext() will work

		addItem("Vegetarian BLT",
			"(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
		addItem("BLT",
			"Bacon with lettuce & tomato on whole wheat", false, 2.99);
		addItem("Soup of the day",
			"Soup of the day, with a side of potato salad", false, 3.29);
		addItem("Hotdog",
			"A hot dog, with saurkraut, relish, onions, topped with cheese",
			false, 3.05);
		addItem("Steamed Veggies and Brown Rice",
			"Steamed vegetables over brown rice", true, 3.99);
		addItem("Pasta",
			"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
			true, 3.89);
	}

	virtual void addItem(std::string name, std::string description, bool vegetarian, double price) {
		MenuItem* menuItem = new MenuItem(name, description, vegetarian, price);
		if (numberOfItems >= MAX_ITEMS) {
			std::cerr << "Sorry, menu is full!  Can't add item to menu" << std::endl;
		} else {
			menuItems[numberOfItems] = menuItem;
			numberOfItems = numberOfItems + 1;
		}
	}

	virtual MenuItem** getMenuItems() {
		return menuItems;
	}

	virtual Iterator<MenuItem>* createIterator() {
		return dynamic_cast<Iterator<MenuItem>*>(new DinerMenuIterator(menuItems));
	}
	// other menu methods here
};


Then , we define iterator class

#include<./menu.hpp>

template <class T>
class Iterator {
	public: virtual bool hasNext() = 0;
	public: virtual T* next() = 0;
};

class PancakeHouseMenuIterator : public Iterator<MenuItem> {
private:
    std::vector<MenuItem*> items;
	int position;

public:
    PancakeHouseMenuIterator(std::vector<MenuItem*> items) : position(0) {
		this->items = items;
	}

	virtual MenuItem* next() {
	    // return current item, move position to next
		MenuItem* menuItem = items[position];
		position = position + 1;
		return menuItem;
	}

	virtual bool hasNext() {
		if (position >= static_cast<int>(items.size())) {
			return false;
		} else {
			return true;
		}
	}
};

class DinerMenuIterator : public Iterator<MenuItem> {
private:
    MenuItem** items;
	int position;

	DinerMenuIterator(MenuItem** items) : position(0) {
		this->items = items;
	}

	virtual MenuItem* next() {
		MenuItem* menuItem = items[position];
		position = position + 1;
		return menuItem;
	}

	virtual bool hasNext() {
		if (items[position] == 0) {
			return false;
		} else {
			return true;
		}
	}
};
The waitress class 

#include<./menu.hpp>
#include<./iterator.hpp>
#include<vector>

class Waitress {
	PancakeHouseMenu* pancakeHouseMenu;
	DinerMenu* dinerMenu;

public:
    Waitress(PancakeHouseMenu* pancakeHouseMenu, DinerMenu* dinerMenu) {
		this->pancakeHouseMenu = pancakeHouseMenu;
		this->dinerMenu = dinerMenu;
	}

	virtual void printMenu() {
		Iterator<MenuItem>* pancakeIterator = pancakeHouseMenu->createIterator();
		Iterator<MenuItem>* dinerIterator = dinerMenu->createIterator();

		std::cout << "MENU\n----\nBREAKFAST" << std::endl;
		printMenu(pancakeIterator);
		std::cout << "\nLUNCH" << std::endl;
		printMenu(dinerIterator);
	}

	virtual void printVegetarianMenu() {
		printVegetarianMenu(pancakeHouseMenu->createIterator());
		printVegetarianMenu(dinerMenu->createIterator());
	}

	virtual bool isItemVegetarian(std::string name) {
		Iterator<MenuItem>* breakfastIterator = pancakeHouseMenu->createIterator();
		if (isVegetarian(name, breakfastIterator)) {
			return true;
		}
		Iterator<MenuItem>* dinnerIterator = dinerMenu->createIterator();
		if (isVegetarian(name, dinnerIterator)) {
			return true;
		}
		return false;
	}

private:
    virtual void printMenu(Iterator<MenuItem>* iterator) {
		while (iterator->hasNext()) {
			MenuItem* menuItem = dynamic_cast<MenuItem*>(iterator->next());
			std::cout << menuItem->getName() << ", ";
			std::cout << menuItem->getPrice() << " -- ";
			std::cout << menuItem->getDescription() << std::endl;
		}
	}

	void printVegetarianMenu(Iterator<MenuItem>* iterator) {
		while (iterator->hasNext()) {
			MenuItem* menuItem = dynamic_cast<MenuItem*>(iterator->next());
			if (menuItem->isVegetarian()) {
				std::cout << menuItem->getName();
				std::cout << "\t\t" << menuItem->getPrice();
				std::cout << "\t" << menuItem->getDescription() << std::endl;
			}
		}
	}

	bool isVegetarian(std::string name, Iterator<MenuItem>* iterator) {
		while (iterator->hasNext()) {
			MenuItem* menuItem = dynamic_cast<MenuItem*>(iterator->next());
			if (menuItem->getName().compare(name) == 0) {
				if (menuItem->isVegetarian()) {
					return true;
				}
			}
		}
		return false;
	}
};
main function 

#include <iostream>
#include <./menu.hpp>
#include <./iterator.hpp>
#include <./waitress.hpp>

int main()
{
    PancakeHouseMenu* pancakeHouseMenu = new PancakeHouseMenu();
    DinerMenu* dinerMenu = new DinerMenu();

	Waitress* waitress = new Waitress(pancakeHouseMenu, dinerMenu);

	waitress->printMenu();
    return 0;
}

zhucai4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DesignPattern : Iterator
04-19
NULL 博文链接：https://davyjones2010.iteye.com/blog/1876389
Design Patterns - Iterator
qq_34921856的博客
01-12 117
Iterator(迭代器) — 对象行为型模式 提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。 适用场景 访问一个聚合对象的内容而无须暴露它的内部表示。 支持对聚合对象的多种遍历。 为遍历不同的聚合结构提供一个统一的接口（即支持多肽迭代）。 UML图 效果 支持以不同的方式遍历一个聚合 简化了聚合的接口 在同一个聚合上可以有多个遍历 实现 import re import reprlib RE_WOR = re.compile('\w+') class Sent
[Design Pattern] Iterator
weixin_44248034的博客
05-20 79
design pattern——iterator
mardax的专栏
08-15 270
design pattern——iterator
Design Pattern Iterator 迭代器设计模式
靖空间
06-25 1208
这个设计模式感觉非常简单，我们平时写程序的时候也是经常需要调用iterator的，C++和Java都是。 所以感觉没什么特别的，就是需要模仿C++或者Java的iterator类的功能吧。 这里简单写个，使用C++模仿Java的iterator一些功能，呵呵。 首先我们有一个集合类，而这个集合类包含了其他类，当我们需要遍历这个集合类包含的类的时候，就好使用iterator功能了。 比如有一
Visitor-and-Iterator-Design-Pattern
03-14
您已经提供了一个迭代器类Iterator ，用户可以创建它来遍历整个表达式树。 该迭代器的特殊之处在于它多次访问树的每个节点。 没有子节点的节点将被访问一次。 有一个孩子的节点被访问两次（访问孩子之前和之后）。 ...
design-pattern-java.pdf
04-08
自定义语言的实现——解释器模式（五） 自定义语言的实现——解释器模式（六） 迭代器模式-Iterator Pattern 遍历聚合对象中的元素——迭代器模式（一） 遍历聚合对象中的元素——迭代器模式（二） 遍历聚合对象中的...
CoreJava-DesignPattern
05-31
CoreJava-DesignPattern 创意设计模式 -- Abstract Factory - Done -- Builder - Done -- Factory Method -- Object Pool -- Prototype - Done -- Singleton - Done 结构设计模式 -- Adapter -- Bridge -- ...
Design.Patterns.Explained.Simply
12-07
If you have ever bought any programming books, you might have noticed that there are two types of them: books that ...Iterator Mediator Memento Null Object Observer State Strategy Template Method Visitor
design_pattern_singleton
海边的八达通
03-08 519
The Singleton Pattern ensures a class has only one instance, and provides a global point of access to it. What is our motivation to use it? In nearly every application, there is a need to have an
design_pattern_derivative_payoff
海边的八达通
03-21 509
In the option pricing framework, the first component which always changes is option's payoff.  Therefore, we need to  encapsulation the payoff class. First of all, we define an abstract PayOff class,
design_pattern_derivative_randomnumber
海边的八达通
03-22 502
We have implemented payoff, option, statistics class. In our calculation for option price, we have used gsl library to generate random numbers, gsl is a high quality numerical library, however,  to pr
design_pattern_derivative_statistics
海边的八达通
03-22 476
Our monte carlo rounte  lacks any indication of the simulation’s convergence. We could make the routine return standard error, or a convergence table, or simply have it return the value for every sing
design_pattern_factory
海边的八达通
03-04 451
This post implements design pattern factory in . The factory design pattern has three levels, simple factory, factory method, abstract factory method. In OOP terminology, a factory is a class for crea
design_pattern_observer
海边的八达通
03-04 427
This post implements observer pattern in . Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated aut
design_pattern_command
海边的八达通
03-08 421
This post implements the command pattern in the book . The Command Pattern encapsulates a request as an object, thereby, letting you parametrize other objects with different requests, queue or log re
design_pattern_strategy
海边的八达通
03-04 405
This post implement strategy pattern, described in . The class structure is as follows class FlyBehavior{ public: virtual void fly() = 0; }; class FlyWithWings : public FlyBehavior{ public:
design_pattern_derivative_option
海边的八达通
03-22 395
If we consider option as a whole, the basic components are expiration and payoff. We want to define a Vanilla Option class which has as data members a PayOff object and a double to represent expiry. H
regex_token_iterator
最新发布
07-27
std::regex_token_iterator<std::string::iterator> iter(str.begin(), str.end(), pattern, -1); std::regex_token_iterator<std::string::iterator> end; while (iter != end) { std::cout *iter ; ++iter;...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值