【C++设计模式】迭代器模式

#ifndef __ITERATOR_H__
#define __ITERATOR_H__

#include <string>
#include <vector>

//【定义】
// 迭代器模式（Iterator）：提供一种方法顺序访问一个集合对象中各个元素, 而又不需暴露该对象的内部表示。

//【角色】
// 1) 迭代器角色（Iterator）：定义遍历元素所需要的方法，一般来说会有这么两个方法：取得下一个元素的方法Next()，判断是否遍历结束的方法HasNext()
// 2) 具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。
// 3) 容器角色(Aggregate)：一般是一个接口，提供一个GetIterator()方法。
// 4) 具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，

//【意义】
// 引入迭代器后可将遍历和实现分离开来。
// 访问一个聚合对象的内容而无需暴露它的内部表示。
// 为遍历不同的聚合结构提供一个统一的接口。

//【示例】

class iIterator;

//集合中的元素
class Book
{
public:
	Book(const std::string & name) : m_name(name){ }

	~Book(){ }

public:
	void SetName(std::string & name);

	std::string GetName();

private:
	std::string m_name;
};

//该角色负责定义创建Iterator的接口，个人感觉有时候可以不必引入该角色
class iAggregate
{
public:
	iAggregate(){ }

	virtual ~iAggregate(){ }

public:
	virtual iIterator * GetIterator() = 0;
};

//具体集合，负责实现创建Iterator的接口，该角色包含了遍历集合所必需的信息
class BookShelf : public iAggregate
{
public:
	BookShelf();

	~BookShelf();

	void Push(Book * book);

	Book * Pop();

	iIterator * GetIterator();

public:
	std::vector<Book*> m_BookVct;
};

//迭代器，该角色负责定义逐个遍历元素的接口
class iIterator
{
public:
	iIterator(){ }

	virtual ~iIterator(){ }

public:
	virtual int HasNext() = 0;

	virtual Book * Next() = 0;

};

//具体迭代器，该角色负责实现iIterator定义的接口
class BookShelfIterator : public iIterator
{
public:
	BookShelfIterator(BookShelf * bookshelf) : m_BookShelf(bookshelf), m_BookIndex(0){ }

	~BookShelfIterator(){ }

public:
	virtual int HasNext();

	virtual Book * Next();

private:
	BookShelf *  m_BookShelf;
	unsigned int m_BookIndex;
};

void TestIterator();


#endif

#include "Iterator.h"

void Book::SetName(std::string & name)
{
	m_name = name;
}

std::string Book::GetName()
{
	return m_name;
}

BookShelf::BookShelf()
{

}

BookShelf::~BookShelf()
{
	for (size_t i=0; i<m_BookVct.size(); i++)
	{
		delete m_BookVct[i];
	}
}

void BookShelf::Push(Book * book)
{
	m_BookVct.push_back(book);
}

Book * BookShelf::Pop()
{
	if (m_BookVct.empty())
	{
		return NULL;
	}

	Book * book = m_BookVct[m_BookVct.size()-1];
	m_BookVct.pop_back();

	return book;
}

iIterator * BookShelf::GetIterator()
{
	return new BookShelfIterator(this);
}

int BookShelfIterator::HasNext()
{
	if (m_BookShelf->m_BookVct.size() > m_BookIndex)
	{
		return 1;
	}

	return 0;
}

Book * BookShelfIterator::Next()
{
	Book * book = m_BookShelf->m_BookVct[m_BookIndex];
	m_BookIndex++;
	return book;
}

void TestIterator()
{
	Book * b1 = new Book(std::string("C++"));
	Book * b2 = new Book(std::string("Java"));
	Book * b3 = new Book(std::string("Scala"));

	BookShelf bookshelf;
	bookshelf.Push(b3);
	bookshelf.Push(b2);
	bookshelf.Push(b1);
	
	//这里的遍历过程不依赖于BookShelf的实现
	iIterator * iter = bookshelf.GetIterator();

	while (iter->HasNext())
	{
		Book * book = iter->Next();

		printf("BookName = %s \n", book->GetName().c_str());
	}

	delete iter;

	return;
}