C++25设计模式之迭代器模式

图片引用于百度

简介：提供一种方法顺序访问一个聚合对象中的各种元素

优点：访问一个聚合对象的内容，不会暴露对象的内部表示，甚至可以自定义迭代器的子类以支持新的遍历

缺点：增加了类的个数，这在一定程度上增加了系统的复杂性

例子背景：遍历一个数组

迭代器模式代码：

• 抽象迭代类：

#pragma once

template <typename T>
class Iterator
{
public:
        Iterator() = default;
        virtual ~Iterator() = default;
public:
        virtual T Next() = 0;
        virtual bool hasNext() = 0;
};

• 抽象数组保存类：

#pragma once
#include "Iterator.h"

template <typename T>
class Aggregate
{
public:
        Aggregate() = default;
        virtual ~Aggregate() = default;
public:
        virtual Iterator<T>* CreateIterator() = 0;
};

• 具体迭代类：

#pragma once
#include "Aggregate.h"
#include <vector>
using namespace std;

template <typename T>
class ConcreteAggregate : public Aggregate<T>
{
private:
        vector<T> m_lst;
public:
        ConcreteAggregate(T arr[], int len) : m_lst(arr, arr + len) {}
        ~ConcreteAggregate()
        {
        }
public:
        Iterator<T>* CreateIterator()
        {
                return new ConcreteIterator<T>(this);
        }
private:
        template <typename T>
        class ConcreteIterator : public Iterator<T>
        {
        private:
                ConcreteAggregate* m_cIter;
                int m_currentIndex = 0;
        public:
                ConcreteIterator() {}
                ConcreteIterator(ConcreteAggregate* cIter) : m_cIter(cIter) {}
        public:
                T GetItemAt(int idx)
                {
                        return m_cIter->m_lst.at(idx);
                }
                void Append(const T& item)
                {
                        m_cIter->m_lst.push_back(item);
                }
                int Size() const
                {
                        return static_cast<int>(m_cIter->m_lst.size());
                }
                virtual T Next()
                {
                        return GetItemAt(m_currentIndex++);
                }
                virtual bool hasNext()
                {
                        return (Size() > 0 && m_currentIndex < Size());
                }
        };
};

• 引用：

#include "ConcreteAggregate.h"
#include <iostream>
int main()
{
        int arr[] = { 0,1,2,3,4,5 };
        ConcreteAggregate<int> c(arr, 6);
        auto iter = c.CreateIterator();

        while(iter->hasNext())
                cout << iter->Next();

        getchar();
        return 0;
}

总结：
迭代器模式(Iterator)：遍历任务能够交由迭代器完成，简化了聚合类。增加新的聚合类和迭代器类都很方便，无须修改原有代码。封装性好，为遍历不同的聚合结构提供一个统一的接口

作者：丶梦爱
博客：https://blog.csdn.net/u014732297（转载请说明出处）