反復器iteratorはプログラムにどのような役割を果たすのでしょうか.--整理する

3322 ワード

1.ポインタと似ていますが、ポインタ2ではありません.containerではelementを指すポインタに相当するが、その実装はポインタではなくオブジェクトである.  3.大きな面から言えば容器とアルゴリズムの間の接着剤は小さい面から言えばスマートポインタのようなもので、copyアルゴリズムを試して理解を深める:)4.iteratorはcontainerのポインタタイプに相当し、container内の各要素へのオブジェクトの連続的なアクセスを定義できます.5.ソースコードを見てすぐに分かります.私も長い間気を失っていたが、実際にはポインタで、typedefを通じて実現した.template   class   XXX {       ...       ...       typedef   T*   iterator       typedef   const   T*   const_iterator; }; 提案:C++primerを見てソースコードの理解を深める参考:
  :
1)Iterator.h
#ifndef ITERATOR_H
#define ITERATOR_H

typedef int DATA;

class Iterater;

//        
class Aggregate
{
public:
    virtual ~Aggregate(){}

    virtual Iterater* CreateIterater(Aggregate *pAggregate) = 0;
    virtual int GetSize() = 0;
    virtual DATA GetItem(int nIndex) = 0;
};

//         
class Iterater
{
public:
    virtual ~Iterater(){}

    virtual void First()        = 0;
    virtual void Next()            = 0;
    virtual bool IsDone()        = 0;
    virtual DATA CurrentItem()    = 0;

private:
};

//         ,        
class ConcreateAggregate
    : public Aggregate
{
public:
    ConcreateAggregate(int nSize);
    virtual ~ConcreateAggregate();

    virtual Iterater* CreateIterater(Aggregate *pAggregate);
    virtual int GetSize();
    virtual DATA GetItem(int nIndex);

private:
    int m_nSize;
    DATA *m_pData;
};

//   ConcreateAggregate        
class ConcreateIterater
    : public Iterater
{
public:
    ConcreateIterater(Aggregate* pAggregate);
    virtual ~ConcreateIterater(){}

    virtual void First();
    virtual void Next();
    virtual bool IsDone();
    virtual DATA CurrentItem();

private:
    Aggregate  *m_pConcreateAggregate;
    int            m_nIndex;
};

#endif

2)Iterator.cpp
#include <iostream>
#include "Iterator.h"

ConcreateAggregate::ConcreateAggregate(int nSize)
    : m_nSize(nSize)
    , m_pData(NULL)
{
    m_pData = new DATA[m_nSize];
    
    for (int i = 0; i < nSize; ++i)
    {
        m_pData[i] = i;
    }
}

ConcreateAggregate::~ConcreateAggregate()
{
    delete [] m_pData;
    m_pData = NULL;
}

Iterater* ConcreateAggregate::CreateIterater(Aggregate *pAggregate)
{
    return new ConcreateIterater(this);
}

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

DATA ConcreateAggregate::GetItem(int nIndex)
{
    if (nIndex < m_nSize)
    {
        return m_pData[nIndex];
    }
    else
    {
        return -1;
    }
}

ConcreateIterater::ConcreateIterater(Aggregate* pAggregate)
    : m_pConcreateAggregate(pAggregate)
    , m_nIndex(0)
{

}

void ConcreateIterater::First()
{
    m_nIndex = 0;
}

void ConcreateIterater::Next()
{
    if (m_nIndex < m_pConcreateAggregate->GetSize())
    {
        ++m_nIndex;
    }
}

bool ConcreateIterater::IsDone()
{
    return m_nIndex == m_pConcreateAggregate->GetSize();
}

DATA ConcreateIterater::CurrentItem()
{
    return m_pConcreateAggregate->GetItem(m_nIndex);
}

3_Main.cpp
#include "Iterator.h"
#include <iostream>

int main()
{
    Aggregate* pAggregate = new ConcreateAggregate(4);
    Iterater*  pIterater  = new ConcreateIterater(pAggregate);

    for (; false == pIterater->IsDone(); pIterater->Next())
    {
        std::cout << pIterater->CurrentItem() << std::endl;
    }

    return 0;
}