设计模式_迭代器模式(C++)

最新推荐文章于 2025-01-01 22:12:43 发布

zhu2695

最新推荐文章于 2025-01-01 22:12:43 发布

阅读量928

点赞数

分类专栏：设计模式文章标签：设计模式迭代器模式

设计模式专栏收录该内容

10 篇文章

订阅专栏

本文深入探讨了迭代器模式的概念、作用及其在C++中的应用，通过实例展示了如何利用迭代器模式访问和遍历集合对象，同时提供了一个完整的C++实现案例，旨在帮助开发者更好地理解和实践迭代器模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考一：

设计模式迭代器模式 C++实现

迭代器模式（Iterator）把按某种顺序访问一个集合中的元素的方式封装在一个对象中，从而无须知道集合的内部表示就可以访问集合。迭代器模式可能是面向对象软件开发中应用的最广泛的一个设计模式。

GOOD：提供一种方法顺序访问一个聚敛对象的各个元素，而又不暴露该对象的内部表示。为遍历不同的聚集结构提供如开始，下一个，是否结束，当前一项等统一接口。

C++实现：

#include <iostream>

using namespace std;

class IntStack

{

public:

IntStack() { m_nTop = 0; }

virtual ~IntStack() {}

void Push(int);

int Pop();

friend class IntStackIterator;

private:

enum { SIZE = 100 };

int m_nStack[SIZE];

int m_nTop;

};

void IntStack::Push(int nData)

{

if(m_nTop < SIZE)

{

m_nStack[m_nTop++] = nData;

}

else

{

cerr << "超出容量范围。" << endl;

}

int IntStack::Pop()

{

if(m_nTop > 0)

{

return m_nStack[--m_nTop];

}

return 0;

}

class Iterator

{

public:

Iterator() {}

virtual ~Iterator() {}

virtual int operator++() = 0;

virtual int operator++(int) = 0;

};

class IntStackIterator : public Iterator

{

public:

IntStackIterator(IntStack*);

virtual ~IntStackIterator();

int operator++();

int operator++(int);

private:

IntStack* m_pStack;

int m_nIndex;

};

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;

}

int main(int argc, char* argv[])

{

IntStack* pStack = new IntStack;

for(int i = 0; i < 5; ++i)

{

pStack->Push(i);

}

Iterator* pIt = new IntStackIterator(pStack);

for(int i = 0; i < 5; ++i)

{

cout << (*pIt)++ << endl;

}

return 0;

}

参考：大话设计模式实现（C++版）

参考二：

Iterator迭代器模式

解释：

概念：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。

main()，客户

IProject，产品接口

CProject，产品类

IIterator，迭代器接口

IProjectIterator，产品迭代器接口

CProjectIterator，产品迭代器实现类

说明：CProject实现产品类，能够返回一个迭代器的指针。这个迭代器将封装产品类里的一个数组。所以迭代器在运行Next函数时，可以遍历这个数组的所有元素。

简单来说，就是用代码实现vector<int>::iterator或vector<int>::const_iterator。

我们来看代码：

//IProject.h

#pragma once
#include "IProjectIterator.h"
#include <iostream>
using std::string;
class IProject
{
public:
    IProject(void)
    {
    }
    virtual ~IProject(void)
    {
    }
    virtual void Add(string name, int num, int cost) = 0;
    virtual string GetProjectInfo() = 0;
    virtual IProjectIterator* GetIterator() = 0;
    virtual void Erase() = 0;
};

//Project.h

#pragma once
#include "iproject.h"
#include "IProjectIterator.h"
#include <iostream>
#include <vector>
using std::string;
using std::vector;
class CProject :
    public IProject
{
public:
    CProject(void);
    CProject(string name, int num, int cost);
    ~CProject(void);
    string GetProjectInfo();
    void Add(string name, int num, int cost);
    IProjectIterator * GetIterator();
    void Erase();
private:
    string m_name;
    int m_num;
    int m_cost;
    vector<IProject*> m_projectList;
};

//Project.cpp

#include "StdAfx.h"
#include "Project.h"
#include "..\CommonDeclare\Convert.h"
#include "ProjectIterator.h"
#include <iostream>
#include <vector>
using std::string;
using std::vector;
CProject::CProject( void )
{
    m_name = "";
    m_num = 0;
    m_cost = 0;
}
CProject::CProject(string name, int num, int cost) :m_name(name), m_num(num), m_cost(cost)
{
}
CProject::~CProject(void)
{
}
string CProject::GetProjectInfo()
{
    string info = "";
    info.append("项目名称是：");
    info.append(this->m_name);
    info.append("\t项目人数：");
    info.append(CConvert::ToString(m_num));
    info.append("\t项目费用：");
    info.append(CConvert::ToString(m_cost));
    return info;
}
void CProject::Add( string name, int num, int cost )
{
    this->m_projectList.push_back(new CProject(name, num, cost));
}
IProjectIterator * CProject::GetIterator()
{
    return new CProjectIterator(this->m_projectList);
}
void CProject::Erase()
{
    vector<IProject*>::reverse_iterator projectDelIt = m_projectList.rbegin();
    for (; projectDelIt != m_projectList.rend(); projectDelIt++)
    {
        delete (*projectDelIt);
        (*projectDelIt) = NULL;
    }
    m_projectList.clear();
}

//IIterator.h

#pragma once
class IProject;
class IIterator
{
public:
    IIterator(void)
    {
    }
    virtual ~IIterator(void)
    {
    }
    virtual bool HasNext() = 0;
    virtual IProject * Next() = 0;
};

//IProjectIterator.h

#pragma once
#include "iiterator.h"
class IProject;
class IProjectIterator :
    public IIterator
{
public:
    IProjectIterator(void)
    {
    }
    virtual ~IProjectIterator(void)
    {
    }
    virtual bool HasNext() = 0;
    virtual IProject * Next() = 0;
};

//ProjectIterator.h

#pragma once
#include "iprojectiterator.h"
#include "IProject.h"
#include <vector>
using std::vector;
class CProjectIterator :
    public IProjectIterator
{
public:
    CProjectIterator(vector<IProject *> pl);
    ~CProjectIterator(void);
    bool HasNext();
    IProject * Next();
private:
    vector<IProject *> m_projectList;
    size_t m_currentItem;
};

//ProjectIterator.cpp

#include "StdAfx.h"
#include "ProjectIterator.h"
CProjectIterator::CProjectIterator(vector<IProject *> pl) : m_projectList(pl)
{
    m_currentItem = 0;
}
CProjectIterator::~CProjectIterator(void)
{
}
bool CProjectIterator::HasNext()
{
    bool b = true;
    if (m_currentItem >= m_projectList.size())
        b = false;
    return b;
}
IProject * CProjectIterator::Next()
{
    IProject *pp = m_projectList.at(m_currentItem ++);
    return pp;
}

// Iterator.cpp
#include "stdafx.h"
#include "IProject.h"
#include "Project.h"
#include "..\CommonDeclare\Convert.h"
#include "ProjectIterator.h"
#include <iostream>
#include <vector>
using std::vector;
using std::cout;
using std::endl;
void DoIt()
{
    cout << "----------未使用迭代模式----------" << endl;
    vector<IProject*> projectList;

    projectList.push_back(new CProject("星球大战项目", 10, 100000));
    projectList.push_back(new CProject("扭转时空项目", 100, 10000000));
    projectList.push_back(new CProject("超人改造项目", 10000, 1000000000));

    for (int i = 4; i < 6; i ++)
    {
        string name = "";
        name.append("第");
        name.append(CConvert::ToString(i));
        name.append("个项目");
        projectList.push_back(new CProject(name, i * 5, i * 1000000));
    }

    vector<IProject*>::const_iterator projectIt = projectList.begin();
    for (; projectIt != projectList.end(); projectIt++)
        cout << (*projectIt)->GetProjectInfo().c_str() << endl;

    vector<IProject*>::reverse_iterator projectDelIt = projectList.rbegin();
    for (; projectDelIt != projectList.rend(); projectDelIt++)
    {
        delete (*projectDelIt);
        (*projectDelIt) = NULL;
    }
    projectList.clear();
}
void DoNew()
{
    cout << "----------使用迭代模式----------" << endl;
    IProject *pproject = new CProject();
    pproject->Add("星球大战项目", 10, 100000);
    pproject->Add("扭转时空项目", 100, 10000000);
    pproject->Add("超人改造项目", 10000, 1000000000);

    for (int i = 4; i < 6; i ++)
    {
        string name = "";
        name.append("第");
        name.append(CConvert::ToString(i));
        name.append("个项目");
        pproject->Add(name, i * 5, i * 1000000);
    }

    IProjectIterator *pprojectIt = pproject->GetIterator();
    while(pprojectIt->HasNext())
    {
        IProject *p = dynamic_cast<IProject*>(pprojectIt->Next());
        cout << p->GetProjectInfo().c_str() << endl;
    }
    delete pprojectIt;
    pprojectIt = NULL;
    pproject->Erase();
    delete pproject;
    pproject = NULL;
}
int _tmain(int argc, _TCHAR* argv[])
{
    //使用Iterator模式之前
    DoIt();

    //使用Iterator
    DoNew();

    _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
    _CrtDumpMemoryLeaks();

    return 0;
}

这个模式，可能有一点绕，需要再仔细的思考一番。本来希望把模式的工作方式，用最简单易懂的语言来总结，但其实这个总结更难。简单的模式还容易些理解，也容易总结，复杂的就难了。打算在之后，学习数据结构的过程中，都总结出这样一句话来。很期待后面对数据结构的学习，发现自己越来越爱学习了。

参考三：

Iterator几乎是大部分人在初学C++的时候就无意之中接触到的第一种设计模式，因为在STL之中，所有的容器类都有与之相关的迭代器。以前初学STL的时候，时常在看到讲述迭代器作用的时候是这么说的：提供一种方式，使得算法和容器可以独立的变化，而且在访问容器对象的时候不必暴露容器的内部细节，

作用：

提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。

UML结构图：

解析：

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

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

实现：

1）Iterator.h

rator的提供者）就能很好的进行合作，而且不必关心对方是如何事先的，简而言之，Iterator就是算法和容器之间的一座桥梁

/**//********************************************************************
　　　 created:　　　 2006/08/04
　　　 filename:　　　　 Iterator.h
　　　 author:　　　　　　　李创
　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/

　　　 purpose:　　　 Iterator模式的演示代码
*********************************************************************/

#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

/**//********************************************************************
　　　 created:　　　 2006/08/04
　　　 filename:　　　　 Iterator.cpp
　　　 author:　　　　　　　李创
　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/

　　　 purpose:　　　 Iterator模式的演示代码
*********************************************************************/

#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

/**//********************************************************************
　　　 created:　　　 2006/08/08
　　　 filename:　　　　 Main.cpp
　　　 author:　　　　　　　李创
　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/

　　　 purpose:　　　 Iterater模式的演示代码
*********************************************************************/

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

参考四：

迭代器(Iterator)模式

我们知道，在 STL 里提供 Iterator 来遍历 Vector 或者 List 数据结构。

Iterator 模式也正是用来解决对一个聚合对象的遍历问题，将对聚合的遍历封装到一个类中进行，这样就避免暴露这个聚合对象的内部表示的可能。

例如在 STL 里有如相下结构：

二. 迭代器模式

定义：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

比较经典的例子是 STL 里的 for_each 操作：

[cpp] // function called for each element
void print (int elem)
{
    cout << elem << ' ';
}

int main()
{
        vector<int> coll;

        INSERT_ELEMENTS(coll,1,9);

        // for_each 对每个 elem 将调用 print(elem)
        for_each (coll.begin(), coll.end(), // range
                  print);                    // operation
        cout << endl;
}