1、迭代器模式的提出

在软件开发过程中，操作的集合对象内部结构常常变化，在访问这些对象元素的同时，也要保证对象内部的封装性。迭代器模式提供了一种利用面向对象的遍历方法来遍历对象元素。迭代器模式通过抽象一个迭代器类，不同的对象继承自迭代器类，外部通过统一接口访问元素。

2、需求描述

设计一个能添加数据元素的容器类，并且能够遍历容器数据元素。

3、功能实现

（1）UML图如下：

（2）代码实现如下：

#include <iostream>
#include <vector>

// 抽象迭代器接口
template<typename T>
class Iterator {
public:
    virtual T& operator*() = 0;
    virtual Iterator<T>& operator++() = 0;
    virtual bool operator!=(const Iterator<T>& other) const = 0;
    virtual ~Iterator(){};
};

// 具体迭代器类
template<typename T>
class ConcreteIterator : public Iterator<T> {
public:
    ConcreteIterator(T* ptr) : m_ptr(ptr) {}

    T& operator*() override {
        return *m_ptr;
    }

    Iterator<T>& operator++() override {
        ++m_ptr;
        return *this;
    }
    bool operator!=(const Iterator<T>& other) const override {
        const ConcreteIterator* concreteOther = dynamic_cast<const ConcreteIterator*>(&other);
        return m_ptr != concreteOther->m_ptr;
    }

private:
    T* m_ptr;
};

// 具体容器类
template<typename T>
class Container {
public:
    void add(const T& element) {
        m_elements.push_back(element);
    }

    Iterator<T>* begin() {
        return  new ConcreteIterator<T>(&m_elements[0]);
    }

    Iterator<T>* end() {
        return new ConcreteIterator<T>(&m_elements[m_elements.size()]);
    }
private:
    std::vector<T> m_elements;
};

class Client
{
public:
    void doWork()
    {
        Container<float> container;
        container.add(1.0);
        container.add(2.0);
        container.add(3.2);

        Iterator<float>* itBegin = container.begin();
        Iterator<float>* itEnd = container.end();
        while (*itBegin != *itEnd) {
            std::cout << **itBegin << "\n";
            ++(*itBegin);
        }

        delete itBegin;
        delete itEnd;
        itBegin = nullptr;
        itEnd = nullptr;
    }
};

int main() {

    Client obj;
    obj.doWork();
    return 0;
}

程序运行结果如下：

 根据容器下标实现的迭代器模式方法也可参考：设计模式-迭代器模式 C++实现_c++ 迭代器模式_MachineChen的博客-CSDN博客

4、面向对象实现迭代器分析

面向对象实现的迭代器模式是在程序运行时，通过虚函数去操作对象元素；相比于C++中的泛型编程实现迭代器的运行性能较低（泛型编程是在编译时已确定访问的元素），所以建议使用泛型编程实现迭代器。

5、泛型编程实现迭代器

#include <iostream>
#include <vector>

template<typename T>
class Iterator {
public:
    Iterator(T* ptr) : m_ptr(ptr) {}

    // 解引用操作符
    T& operator*() {
        return *m_ptr;
    }

    // 前缀自增操作符
    Iterator& operator++() {
        ++m_ptr;
        return *this;
    }

    // 后缀自增操作符
    Iterator operator++(int) {
        Iterator iterator = *this;
        ++m_ptr;
        return iterator;
    }

    // 比较操作符
    bool operator!=(const Iterator& other) const {
        return m_ptr != other.m_ptr;
    }

private:
    T* m_ptr;
};

template<typename T>
class Container {
public:
    void add(const T& element) {
        m_elements.push_back(element);
    }

    Iterator<T> begin() {
        return Iterator<T>(&m_elements[0]);
    }

    Iterator<T> end() {
        return Iterator<T>(&m_elements[m_elements.size()]);
    }

private:
    std::vector<T> m_elements;
};

class Client
{
public:
    void doWork()
    {
        Container<float> container;
        container.add(1.0);
        container.add(2.0);
        container.add(3.2);

        for (Iterator<float> it = container.begin(); it != container.end(); ++it) {
            std::cout << *it << "\n";
        }
    }
};

int main() {
    Client obj;
    obj.doWork();
    return 0;
}

程序运行结果如下：