设计模式-行为-迭代器

#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;
}