【设计模式】行为型模式-迭代器模式（Iterator Pattern）

迭代器模式（Iterator Pattern）是一种行为型设计模式，它提供一种方法顺序访问聚合对象的元素，而无需暴露其底层表示。以下是针对 C++ 的详细解释和示例：

核心组成

1. 迭代器接口（Iterator）
   • 定义访问和遍历元素的接口
2. 具体迭代器（Concrete Iterator）
   • 实现迭代器接口
   • 跟踪当前遍历位置
3. 聚合接口（Aggregate）
   • 定义创建迭代器对象的接口
4. 具体聚合（Concrete Aggregate）
   • 实现聚合接口，返回具体迭代器实例

C++ 实现示例

#include <iostream>
#include <vector>
#include <list>

// 迭代器接口
template <typename T>
class Iterator {
public:
    virtual ~Iterator() = default;
    virtual T next() = 0;
    virtual bool hasNext() const = 0;
};

// 具体聚合：数组集合
template <typename T>
class ArrayCollection {
    std::vector<T> data;
public:
    void add(const T& item) {
        data.push_back(item);
    }

    Iterator<T>* createIterator() const;
};

// 数组迭代器
template <typename T>
class ArrayIterator : public Iterator<T> {
    const std::vector<T>& data;
    size_t index;
public:
    ArrayIterator(const std::vector<T>& d) : data(d), index(0) {}

    T next() override {
        return data[index++];
    }

    bool hasNext() const override {
        return index < data.size();
    }
};

template <typename T>
Iterator<T>* ArrayCollection<T>::createIterator() const {
    return new ArrayIterator<T>(data);
}

// 具体聚合：链表集合
template <typename T>
class ListCollection {
    std::list<T> data;
public:
    void add(const T& item) {
        data.push_back(item);
    }

    Iterator<T>* createIterator() const;
};

// 链表迭代器
template <typename T>
class ListIterator : public Iterator<T> {
    typename std::list<T>::const_iterator current;
    typename std::list<T>::const_iterator end;
public:
    ListIterator(const std::list<T>& d) : current(d.begin()), end(d.end()) {}

    T next() override {
        return *(current++);
    }

    bool hasNext() const override {
        return current != end;
    }
};

template <typename T>
Iterator<T>* ListCollection<T>::createIterator() const {
    return new ListIterator<T>(data);
}

// 客户端使用
int main() {
    // 使用数组集合
    ArrayCollection<std::string> books;
    books.add("Design Patterns");
    books.add("C++ Primer");
    books.add("Effective C++");

    Iterator<std::string>* it = books.createIterator();
    while(it->hasNext()) {
        std::cout << it->next() << std::endl;
    }
    delete it;

    // 使用链表集合
    ListCollection<int> numbers;
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);

    Iterator<int>* numIt = numbers.createIterator();
    while(numIt->hasNext()) {
        std::cout << numIt->next() << " ";
    }
    delete numIt;

    return 0;
}

关键特点

1. 封装性：隐藏集合内部实现，客户端只需与迭代器交互
2. 多态遍历：可以针对不同数据结构实现不同的遍历方式
3. 并行遍历：支持多个迭代器同时遍历同一集合
4. 开闭原则：新增集合类型时无需修改客户端代码

应用场景

• 需要统一接口遍历不同集合类型
• 需要支持集合的多种遍历方式
• 需要隐藏集合复杂内部结构时
• 需要提供标准遍历接口给第三方使用

注意事项

1. 资源管理：使用智能指针（如 unique_ptr）管理迭代器对象
2. 线程安全：多线程环境需要同步机制
3. 失效处理：集合修改时迭代器可能失效
4. 性能考虑：虚函数调用可能带来开销

C++ 相关特性

• 标准库已提供迭代器模式实现（STL 迭代器）
• 支持 range-based for 循环（C++11 起）
• 可以使用模板实现通用迭代器
• 推荐使用 auto 简化迭代器声明

建议在实际项目中优先使用 STL 迭代器，仅在需要特殊遍历逻辑或自定义集合时实现迭代器模式。