我与C++设计模式（二十一）——迭代器模式

迭代器模式，不用过多的介绍，迭代器在STL中是极具重要地位的。迭代器模式是用来解决对一个对象集合进行遍历的问题，将对集合的遍历封装成类，避免过多暴露。

UML图：

感觉比预想的要复杂。

代码：

#ifndef _AGGREGATE_H__
#define _AGGREGATE_H__

class Iterator;

typedef int object;
class aggregate
{
        public:
                virtual ~aggregate();
                virtual Iterator *create_Iterator() = 0;
                virtual object get_item(int) = 0;
                virtual int get_size() = 0;

        protected:
                aggregate();
};

class concrete_aggregate:public aggregate
{
        public:
                enum{SIZE = 3};
                concrete_aggregate();
                ~concrete_aggregate();
                Iterator *create_Iterator();
                object get_item(int);
                int get_size();
        private:
                object _obj[SIZE];
};
#endif

#ifndef _AGGREGATE_H__
#define _AGGREGATE_H__

class Iterator;

typedef int object;
class aggregate
{
        public:
                virtual ~aggregate();
                virtual Iterator *create_Iterator() = 0;
                virtual object get_item(int) = 0;
                virtual int get_size() = 0;

        protected:
                aggregate();
};

class concrete_aggregate:public aggregate
{
        public:
                enum{SIZE = 3};
                concrete_aggregate();
                ~concrete_aggregate();
                Iterator *create_Iterator();
                object get_item(int);
                int get_size();
        private:
                object _obj[SIZE];
};
#endif

Administrator@5guo-PC ~/pattern23/iterator
$ cat aggregate.cpp
//aggregate.cpp

#include "aggregate.h"
#include "iterator.h"

aggregate::aggregate()
{
}

aggregate::~aggregate()
{
}

concrete_aggregate::concrete_aggregate()
{
        for (int i = 0; i < SIZE; ++i)
                _obj[i] = i;
}

concrete_aggregate::~concrete_aggregate()
{
}

Iterator *concrete_aggregate::create_Iterator()
{
        return new concrete_Iterator(this);
}

object concrete_aggregate::get_item(int index)
{
        if (index < get_size())
                return _obj[index];
        else
                return -1;
}

int concrete_aggregate::get_size()
{
        return SIZE;
}

#ifndef _ITERATOR_H__
#define _ITERATOR_H__

class aggregate;

typedef int object;

class Iterator
{
        public:
                virtual ~Iterator();
                virtual void first() = 0;
                virtual void next() = 0;
                virtual bool is_done() = 0;
                virtual object current_item() = 0;

        protected:
                Iterator();
};

class concrete_Iterator:public Iterator
{
        public:
                concrete_Iterator(aggregate *,int index = 0);
                ~concrete_Iterator();
                void first();
                void next();
                bool is_done();
                object current_item();

        private:
                aggregate *_p_ag;
                int _idx;
};

#endif

//Iterator.cpp

#include "aggregate.h"
#include "Iterator.h"

Iterator::Iterator()
{
}

Iterator::~Iterator()
{
}

concrete_Iterator::concrete_Iterator(aggregate *p_ag,int index)
        :_p_ag(p_ag),_idx(index)
{
}

concrete_Iterator::~concrete_Iterator()
{
}

object concrete_Iterator::current_item()
{
        return _p_ag->get_item(_idx);
}

void concrete_Iterator::first()
{
        _idx = 0;
}

void concrete_Iterator::next()
{
        if (_idx < _p_ag->get_size())
                ++_idx;
}

bool concrete_Iterator::is_done()
{
        return _idx == _p_ag->get_size();
}

//main.cpp

#include "Iterator.h"
#include "aggregate.h"
#include <iostream>
using namespace std;

int main(int argc,char **argv)
{
        aggregate *p_ag = new concrete_aggregate();
        Iterator *p_ite = new concrete_Iterator(p_ag);

        for ( ; !(p_ite->is_done()); p_ite->next())
                cout<<p_ite->current_item()<<endl;

        return 0;
}