设计模式(C++)-行为型模式-迭代器模式
一、迭代器模式概述
迭代器模式（iterator pattern）:是一种行为型设计模式，它提供一种方法顺序访问 一个聚合对象中的各个元素，而又不暴露其内部表示。
核心思想 ：提供一种方法，可以顺序访问聚合对象中的元素，而不需要了解底层表示，将遍历逻辑从聚合对象中分离出来，实现了单一职责原则。
总结：
- 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。
- 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
- 提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。
- 当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式
二、迭代器模式UML类图
三、代码实现
cpp
//Iterator.h
#pragma once
/*Iterator 模式（迭代器模式)
迭代器模式是一种设计模式，它提供了一种方法来顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示
总结：
- 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。
- 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
- 提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。
- 当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式
*/
#include <iostream>
using namespace std;
//抽象的迭代器类
class Iterator {
public:
virtual ~Iterator() {};
virtual void first() = 0;
virtual void next() = 0;
virtual bool isDone() = 0;
virtual int currentItem() = 0;
};
//抽象聚合类
class Aggregate {
public:
virtual ~Aggregate() {};
virtual Iterator* createIterator() = 0;
};
//具体聚合类
class ConcreteIterator;
class ConcreteAggregate :public Aggregate {
public:
ConcreteAggregate() {
for (size_t i = 0; i < 5; i++)
{
item[i] = i;
}
}
Iterator* createIterator()override;
int getSize()const;
int getItem(int index)const;
private:
int item[5];
};
//具体迭代器
class ConcreteIterator :public Iterator {
public:
ConcreteIterator(ConcreteAggregate*a):m_aggregate(a), m_current(0) {}
virtual void first() override;
virtual void next() override;
virtual bool isDone() override;
virtual int currentItem()override;
private:
ConcreteAggregate* m_aggregate;
int m_current;
};
void testIterator();
//Iterator.cc
#include "Iterator.h"
#include <memory>
Iterator* ConcreteAggregate::createIterator() {
return new ConcreteIterator(this);
}
int ConcreteAggregate::getSize()const{
return 5;
}
int ConcreteAggregate::getItem(int index)const{
return item[index];
}
void ConcreteIterator::first() {
m_current = 0;
}
void ConcreteIterator::next() {
m_current++;
}
bool ConcreteIterator::isDone() {
return m_current >= m_aggregate->getSize();
}
int ConcreteIterator::currentItem() {
return m_aggregate->getItem(m_current);
}
void testIterator() {
cout << "=================Iterator begin===============" << endl;
std::shared_ptr<Aggregate> aggregate = std::make_shared<ConcreteAggregate>();
Iterator* iterator = aggregate->createIterator();
while (!iterator->isDone())
{
cout << iterator->currentItem() << " ";
iterator->next();
}
cout << endl;
cout << "=================Iterator end===============" << endl;
}四、优缺点总结
优点：
- 单一职责原则：将遍历算法与聚合对象分离
- 开闭原则：可以新增迭代器类型而不修改聚合类
- 并行遍历：可以在同一聚合上同时进行多个遍历
- 延迟遍历：可以按需获取元素，不需要一次性加载所有数据
- 统一接口：为不同的聚合结构提供统一的遍历接口
缺点：
- 增加复杂度：对于简单集合可能过于复杂
- 性能开销：迭代器对象创建和虚函数调用可能带来开销
- 可能破坏封装：某些迭代器可能需要访问聚合内部细节