设计模式之迭代器模式（四）

 迭代器模式

参考：http://www.cnblogs.com/wanggary/archive/2011/04/19/2021600.html

http://www.ecjtu.org/archiver/?tid-18153.html

http://www.cppblog.com/emptysoul/archive/2009/02/15/73868.aspx

 

代码参考 Iterator 文件。 在我的资源中下载可用

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各个元素，而不是暴露 该对象的内部表示当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该用迭代器模式

 

Iterator几乎是大部分人在初学C++的时候就无意之中接触到的第一种设计模式,因为在STL之中,所有的容器类都有与之相关的迭代器.以前初学STL的时候,时常在看到讲述迭代器作用的时候是这么说的:提供一种方式,使得算法和容器可以独立的变化,而且在访问容器对象的时候不必暴露容器的内部细节,具体是怎么做到这一点的呢?在STL的实现中,所有的迭代器(Iterator)都必须遵照一套规范,这套规范里面定义了几种类型的名称,比如对象的名称,指向对象的指针的名称,指向对象的引用的名称....等等,当新生成一个容器的时候与之对应的Iterator都要遵守这个规范里面所定义的名称,这样在外部看来虽然里面的实现细节不一样,但是作用(也就是对外的表象)都是一样的,通过某个名称可以得到容器包含的对象,通过某个名称可以得到容器包含的对象的指针等等的.而且,采用这个模式把访问容器的重任都交给了具体的iterator类中.于是,在使用Iterator来访问容器对象的算法不需要知道需要处理的是什么容器,只需要遵守事先约定好的Iterator的规范就可以了;而对于各个容器类而言,不管内部的事先如何,是树还是链表还是数组,只需要对外的接口也遵守Iterator的标准,这样算法(Iterator的使用者)和容器(Iterator的提供者)就能很好的进行合作,而且不必关心对方是如何事先的,简而言之,Iterator就是算法和容器之间的一座桥梁.

在下面的实现中,抽象基类Iterator可以看做是前面提到的Iterator的规范,它提供了所有Iterator需要遵守的规范也就是对外的接口,而它的派生类ConcreateIterator则是ConcreateAggregate容器的迭代器,它遵照这个规范对容器进行迭代和访问操作。

 

http://www.cppblog.com/emptysoul/archive/2009/02/15/73868.aspx

 

//IntStack.h
class IntStack
{
public:
    IntStack();
    virtual ~IntStack();

    void Push(int);
    int Pop();
    friend class IntStackIterator;
private:
    enum { SIZE = 100 }; 
    int m_nStack[SIZE];
    int m_nTop;
};

//IntStack.cpp
#include "stdafx.h"
#include "IntStack.h"
#include <iostream>

using namespace std;

IntStack::IntStack()
{
    m_nTop = 0;
}

IntStack::~IntStack()
{

}

void IntStack::Push(int nData)
{
    if(m_nTop < SIZE)
    {
        m_nStack[m_nTop++] = nData;
    }
    else
    {
        cout << "超出容量范围。" << endl;
    }
}

int IntStack::Pop()
{
    if(m_nTop > 0)
    {
        return m_nStack[--m_nTop];
    }

    return 0;
}

//Iterator.h
class Iterator  
{
public:
    Iterator();
    virtual ~Iterator();

    virtual int operator++() = 0;
    virtual int operator++(int) = 0;
};

//Iterator.cpp
#include "stdafx.h"
#include "Iterator.h"

Iterator::Iterator()
{

}

Iterator::~Iterator()
{

}

//IntStack.h
#include "Iterator.h"

class IntStack;
class IntStackIterator : public Iterator
{
public:
    IntStackIterator(IntStack*);
    virtual ~IntStackIterator();

    int operator++();
    int operator++(int);
private:
    IntStack* m_pStack;
    int m_nIndex;
};

//IntStackIterator.cpp
#include "stdafx.h"
#include "IntStackIterator.h"
#include "IntStack.h"

IntStackIterator::IntStackIterator(IntStack* pStack)
{
    m_pStack = pStack;
    m_nIndex = 0;
}

IntStackIterator::~IntStackIterator()
{
    if(m_pStack != NULL)
    {
        delete m_pStack;
        m_pStack = NULL;
    }
}

int IntStackIterator::operator++()
{
    if(m_nIndex < m_pStack->m_nTop)
    {
        return m_pStack->m_nStack[++m_nIndex];
    }

    return 0;
}

int IntStackIterator::operator++(int)
{
    if(m_nIndex < m_pStack->m_nTop)
    {
        return m_pStack->m_nStack[m_nIndex++];
    }

    return 0;
}

//main.cpp
#include "stdafx.h"
#include "Iterator.h"
#include "IntStackIterator.h"
#include "IntStack.h"
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
    IntStack* pStack = new IntStack;
    for(int i = 0; i < 20; ++i)
    {
        pStack->Push(i);
    }

    Iterator* pIt = new IntStackIterator(pStack);
    for(i = 0; i < 20; ++i)
    {
        cout << (*pIt)++ << endl;
    }

    return 0;
}