设计模式-行为-迭代器

#pragma once

#ifndef ITERATOR_H 

#define ITERATOR_H 

#include <vector>
#include <iostream>
using namespace std;

class Iterater; 

// 容器的抽象基类
template <class DATA> class Aggregate 
{ 
public: 
	virtual ~Aggregate(){} 
	virtual int GetSize() = 0; 
	virtual DATA GetItem(int nIndex) = 0; 
}; 

// 迭代器的抽象基类 
class Iterater 
{ 
public: 
	virtual ~Iterater(){} 
	virtual Iterater& operator++() = 0;
	virtual Iterater& operator++(int) = 0;
private: 
}; 

// 一个具体的容器类,这里是用数组表示
template <class DATA> class ConcreateIterater;

template <class DATA=int, typename MAX_SIZE=1024> class ConcreateAggregate : public Aggregate<DATA> 
{ 
public: 
	ConcreateAggregate(); 
	virtual ~ConcreateAggregate(); 
	virtual ConcreateIterater<DATA>& begin();
	virtual ConcreateIterater<DATA>& end();
	virtual void push_back(DATA dt);
	virtual DATA pop_back();
	virtual int GetSize();
	virtual DATA GetItem(int nIndex);
	DATA operator[](size_t nIndex)
	{
		if (nIndex >= m_aData.size())
		{
			cout<<"index out of range"<<endl;
			return -1;
		}
		return m_aData[nIndex];
	}

private:
	ConcreateIterater<DATA> *m_begin;
	ConcreateIterater<DATA> *m_end;
	vector<DATA> m_aData;
}; 

// 访问ConcreateAggregate 容器类的迭代器类 
template <class DATA> class ConcreateIterater : public Iterater 
{
public: 
	ConcreateIterater(Aggregate<DATA>* pAggregate)
		: m_pConcreateAggregate(pAggregate) 
		, m_nIndex(0) 
	{ 
	} 
	virtual ~ConcreateIterater(){} 
	ConcreateIterater& operator*()
	{
		return *this;
	}
	friend ostream &operator<<(ostream &os,const ConcreateIterater &itr)
	{
		os << itr.m_pConcreateAggregate->GetItem(itr.m_nIndex);

		return os;
	}
	friend istream &operator>>(istream &is,ConcreateIterater &itr)
	{
		int tmp = itr.m_pConcreateAggregate->GetItem(itr.m_nIndex);
		is >> tmp;
		return is;
	}
	virtual Iterater& operator++()//for ++itr
	{
		m_nIndex++;
		return *this;
	}
	virtual Iterater& operator++(int) //for itr++
	{
		ConcreateIterater *tmp = this;
		m_nIndex++;
		return *tmp;
	}
	bool operator==(ConcreateIterater itr)
	{
		return this->m_nIndex == itr.m_nIndex;
	}
	bool operator!=(ConcreateIterater itr)
	{
		return this->m_nIndex != itr.m_nIndex;
	}

	template <class DATA, int MAX_SIZE> friend class ConcreateAggregate;
private: 
	Aggregate<DATA>   *m_pConcreateAggregate; 
	int         m_nIndex; 
}; 

#endif 

#include "StdAfx.h"
#include "iterator_impl.h"

#include <iostream> 
template <class DATA, int MAX_SIZE>
ConcreateAggregate<DATA, MAX_SIZE>::ConcreateAggregate()
:m_begin(NULL)
,m_end(NULL)
{
} 
template <class DATA, int MAX_SIZE>
ConcreateAggregate<DATA, MAX_SIZE>::~ConcreateAggregate() 
{ 
} 
template <class DATA, int MAX_SIZE>
ConcreateIterater<DATA>& ConcreateAggregate<DATA, MAX_SIZE>::begin()
{
	if (m_begin == NULL)
	{
		m_begin = new ConcreateIterater<DATA>(this);
		m_begin->m_nIndex = 0;
	}
	
	return *m_begin;
}
template <class DATA, int MAX_SIZE>
ConcreateIterater<DATA>& ConcreateAggregate<DATA, MAX_SIZE>::end()
{
	if (m_end == NULL)
	{
		m_end = new ConcreateIterater<DATA>(this);
		m_end->m_nIndex = m_aData.size();
	}

	return *m_end;
}
template <class DATA, int MAX_SIZE>
void ConcreateAggregate<DATA, MAX_SIZE>::push_back(DATA dt)
{
	m_aData.push_back(dt);
}
template <class DATA, int MAX_SIZE>
DATA ConcreateAggregate<DATA, MAX_SIZE>::pop_back()
{
	DATA tmp = m_aData.back();
	m_aData.pop_back();
	return tmp;
}
template <class DATA, int MAX_SIZE>
int ConcreateAggregate<DATA, MAX_SIZE>::GetSize() 
{ 
	return m_aData.size(); 
} 
template <class DATA, int MAX_SIZE>
DATA ConcreateAggregate<DATA, MAX_SIZE>::GetItem(int nIndex) 
{ 
	if (nIndex < m_aData.size()) 
	{ 
		return m_aData[nIndex]; 
	} 
	return -1; 
} 

// Iterator.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "iterator_impl.h"
#include "iterator_impl.cpp"
#include <stdlib.h>
#include <memory>
#include <iostream>
using namespace std;
//提供一种方法顺序访问一个聚合对象中各个元素,,而又不需暴露该对象的内部表示.
typedef ConcreateAggregate<> dmVector;
typedef ConcreateAggregate<int,64> mVector;
typedef ConcreateIterater<int> mIterator;
int _tmain(int argc, _TCHAR* argv[])
{
	mVector vtdata;
	vtdata.push_back(1);
 	vtdata.push_back(2);
 	vtdata.push_back(3);
 	vtdata.push_back(4);
	for (mIterator itr  = vtdata.begin();itr != vtdata.end(); itr++) 
	{ 
		std::cout << *itr <<" "; 
	} 
	cout<<endl;
	for (int i=0;i<vtdata.GetSize();++i)
	{
		std::cout<<vtdata[i]<<" ";
	}
	cout<<endl;

	system("pause");

	return 0;
}