设计模式之迭代器模式

优点：没看懂。

体会：没体会。

迭代器基类

#pragma once

typedef int Object;

class Iterator
{
public:
    virtual ~Iterator();

    virtual void First() = 0;

    virtual void Next() = 0;

    virtual bool IsDone() = 0;

    virtual Object CurrentItem() = 0;

protected:
    Iterator();
};

#include "Iterator.h"


Iterator::Iterator()
{
}


Iterator::~Iterator()
{
}

 

迭代器派生类

#pragma once
#include "Iterator.h"

class Aggregate;

class ConcreateIterator :
    public Iterator
{
public:
    ConcreateIterator(Aggregate *ag, int idx = 0);

    ~ConcreateIterator();

    void First();

    void Next();

    bool IsDone();

    Object CurrentItem();

private:
    Aggregate *m_ag;

    int m_idx;
};

#include "ConcreateIterator.h"
#include "Aggregate.h"


ConcreateIterator::ConcreateIterator(Aggregate *ag, int idx)
{
    this->m_ag = ag;

    this->m_idx = idx;
}


ConcreateIterator::~ConcreateIterator()
{
}

void ConcreateIterator::First()
{
    m_idx = 0;
    return;
}

void ConcreateIterator::Next()
{
    if (m_idx < m_ag->GetSize())
    {
        m_idx++;
    }
    return;
}

bool ConcreateIterator::IsDone()
{
    return (m_idx == m_ag->GetSize());
}

Object ConcreateIterator::CurrentItem()
{
    return m_ag->GetItem(m_idx);
}

 

对象类的基类

#include "Aggregate.h"


Aggregate::Aggregate()
{
}


Aggregate::~Aggregate()
{
}

#pragma once

class Iterator;

typedef int Object;

class Aggregate
{
public:
    virtual~Aggregate();

    virtual Iterator *CreateIterator() = 0;

    virtual Object GetItem(int idx) = 0;

    virtual int GetSize() = 0;

protected:
    Aggregate();
};

 

对象类

#pragma once
#include "Aggregate.h"

class ConcreateIterator;

class ConcreateAggregate :
    public Aggregate
{
public:
    enum 
    {
        SIZE = 3
    };

    ConcreateAggregate();

    ~ConcreateAggregate();

    Iterator *CreateIterator();

    Object GetItem(int idx);

    int GetSize();

private:
    Object m_objs[SIZE];

    ConcreateIterator *m_concreate_iterator;
};

#include "ConcreateAggregate.h"
#include "ConcreateIterator.h"


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


ConcreateAggregate::~ConcreateAggregate()
{
}

Iterator *ConcreateAggregate::CreateIterator()
{
    m_concreate_iterator = new ConcreateIterator(this);
    return m_concreate_iterator;
}

Object ConcreateAggregate::GetItem(int idx)
{
    if (idx < this->GetSize())
    {
        return m_objs[idx];
    }
    else
    {
        return -1;
    }
}

int ConcreateAggregate::GetSize()
{
    return SIZE;
}

 

测试

#include <iostream>
#include "ConcreateAggregate.h"
#include "ConcreateIterator.h"

int main()
{
    Aggregate *ag = new ConcreateAggregate();

    Iterator *it = new ConcreateIterator(ag);

    for (; !(it->IsDone()); it->Next())
    {
        std::cout << it->CurrentItem() << std::endl;
    }

    if (it)
    {
        delete it;
        it = NULL;
    }

    if (ag)
    {
        delete ag;
        ag = NULL;
    }

    std::cout << "Hello World!\n"; 
}