行为型模式：④迭代器模式（Iterator Pattern）
核心思想
分离聚合对象的 “遍历逻辑” 与 “存储逻辑”，定义一个独立的 “迭代器” 对象，由迭代器负责顺序访问聚合对象（如数组、链表、集合）的元素，而不暴露聚合对象的内部结构（如底层存储方式、索引规则）。核心价值是：
客户端可通过统一接口遍历不同类型的聚合对象（如数组、链表），无需关心聚合的内部实现；
聚合对象仅负责存储数据，迭代器负责遍历，符合 “单一职责原则”；
支持多种遍历方式（如正向、反向、过滤遍历），可独立扩展迭代器而不修改聚合对象。
核心本质
遍历行为封装，将 “怎么遍历” 从 “存什么” 中抽离，实现遍历与存储的解耦。
典型场景
遍历复杂聚合结构（如链表、树、哈希表），客户端无需了解内部存储逻辑；
需统一不同聚合对象的遍历接口（如同时遍历数组和链表，用相同的hasNext()/next()操作）；
需扩展多种遍历方式（如正向遍历、反向遍历、按条件过滤遍历）。
C语言编写（结构体 + 函数指针 + 解耦遍历）
C 语言无类，通过 “结构体模拟角色”“函数指针定义统一接口”，实现迭代器与聚合的分离。用Iterator结构体封装遍历逻辑，Aggregate结构体封装数据存储，迭代器持有聚合的指针，独立完成遍历。
场景示例
两种聚合对象：动态数组（ArrayAggregate）、单向链表（ListAggregate），通过统一的迭代器接口遍历，客户端无需区分聚合类型。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 最大元素数量（动态数组用）
#define MAX_ARRAY_SIZE 10
// -------------------------- 1. 抽象迭代器（Iterator）：统一遍历接口 --------------------------
typedef struct Iterator {
// 是否还有下一个元素
int (*has_next)(struct Iterator* self);
// 移动到下一个元素，返回是否成功
int (*next)(struct Iterator* self);
// 获取当前元素
void* (*current)(struct Iterator* self);
// 销毁迭代器
void (*destroy)(struct Iterator* self);
// 持有聚合对象指针（用于访问数据）
void* aggregate;
// 遍历状态（数组：当前索引；链表：当前节点）
void* state;
} Iterator;
// -------------------------- 2. 具体聚合1：动态数组（ArrayAggregate） --------------------------
typedef struct ArrayAggregate {
// 抽象聚合接口
Iterator* (*create_iterator)(struct ArrayAggregate* self);
void (*add)(struct ArrayAggregate* self, void* data);
void (*destroy)(struct ArrayAggregate* self);
// 数组内部存储
void* data[MAX_ARRAY_SIZE];
int size; // 实际元素个数
} ArrayAggregate;
// 数组聚合：添加元素
void array_add(ArrayAggregate* self, void* data) {
if (self->size >= MAX_ARRAY_SIZE) {
printf("数组已满，无法添加元素！\n");
return;
}
self->data[self->size++] = data;
}
// 数组迭代器：has_next实现
int array_iter_has_next(Iterator* self) {
int* index = (int*)self->state;
ArrayAggregate* array = (ArrayAggregate*)self->aggregate;
return *index < array->size;
}
// 数组迭代器：next实现（移动索引）
int array_iter_next(Iterator* self) {
int* index = (int*)self->state;
if (array_iter_has_next(self)) {
(*index)++;
return 1;
}
return 0;
}
// 数组迭代器：current实现（返回当前元素）
void* array_iter_current(Iterator* self) {
int* index = (int*)self->state;
ArrayAggregate* array = (ArrayAggregate*)self->aggregate;
// 注意：next后索引+1，当前元素是index-1
return array->data[*index - 1];
}
// 数组迭代器：destroy实现
void array_iter_destroy(Iterator* self) {
free(self->state); // 释放索引状态
free(self);
}
// 数组聚合：创建数组迭代器
Iterator* array_create_iterator(ArrayAggregate* self) {
Iterator* iter = (Iterator*)malloc(sizeof(Iterator));
iter->aggregate = self;
// 初始化遍历状态：索引从0开始
int* index = (int*)malloc(sizeof(int));
*index = 0;
iter->state = index;
// 绑定迭代器接口实现
iter->has_next = array_iter_has_next;
iter->next = array_iter_next;
iter->current = array_iter_current;
iter->destroy = array_iter_destroy;
return iter;
}
// 数组聚合：destroy实现
void array_destroy(ArrayAggregate* self) {
free(self);
}
// 创建数组聚合
ArrayAggregate* create_array_aggregate() {
ArrayAggregate* array = (ArrayAggregate*)malloc(sizeof(ArrayAggregate));
array->size = 0;
array->create_iterator = array_create_iterator;
array->add = array_add;
array->destroy = array_destroy;
memset(array->data, 0, sizeof(array->data));
return array;
}
// -------------------------- 3. 具体聚合2：单向链表（ListAggregate） --------------------------
// 链表节点
typedef struct ListNode {
void* data;
struct ListNode* next;
} ListNode;
typedef struct ListAggregate {
// 抽象聚合接口
Iterator* (*create_iterator)(struct ListAggregate* self);
void (*add)(struct ListAggregate* self, void* data);
void (*destroy)(struct ListAggregate* self);
// 链表内部存储
ListNode* head;
ListNode* tail;
int size;
} ListAggregate;
// 链表聚合：添加元素
void list_add(ListAggregate* self, void* data) {
ListNode* node = (ListNode*)malloc(sizeof(ListNode));
node->data = data;
node->next = NULL;
if (self->tail == NULL) {
self->head = node;
self->tail = node;
} else {
self->tail->next = node;
self->tail = node;
}
self->size++;
}
// 链表迭代器：has_next实现
int list_iter_has_next(Iterator* self) {
ListNode** current_node = (ListNode**)self->state;
return *current_node != NULL;
}
// 链表迭代器：next实现（移动到下一个节点）
int list_iter_next(Iterator* self) {
ListNode** current_node = (ListNode**)self->state;
if (list_iter_has_next(self)) {
*current_node = (*current_node)->next;
return 1;
}
return 0;
}
// 链表迭代器：current实现（返回当前节点数据）
void* list_iter_current(Iterator* self) {
ListNode** current_node = (ListNode**)self->state;
return (*current_node)->data;
}
// 链表迭代器：destroy实现
void list_iter_destroy(Iterator* self) {
free(self->state); // 释放当前节点指针
free(self);
}
// 链表聚合：创建链表迭代器
Iterator* list_create_iterator(ListAggregate* self) {
Iterator* iter = (Iterator*)malloc(sizeof(Iterator));
iter->aggregate = self;
// 初始化遍历状态：指向头节点
ListNode** current_node = (ListNode**)malloc(sizeof(ListNode*));
*current_node = self->head;
iter->state = current_node;
// 绑定迭代器接口实现
iter->has_next = list_iter_has_next;
iter->next = list_iter_next;
iter->current = list_iter_current;
iter->destroy = list_iter_destroy;
return iter;
}
// 链表聚合：destroy实现（递归销毁节点）
void list_destroy(ListAggregate* self) {
ListNode* temp = self->head;
while (temp != NULL) {
ListNode* next = temp->next;
free(temp);
temp = next;
}
free(self);
}
// 创建链表聚合
ListAggregate* create_list_aggregate() {
ListAggregate* list = (ListAggregate*)malloc(sizeof(ListAggregate));
list->head = NULL;
list->tail = NULL;
list->size = 0;
list->create_iterator = list_create_iterator;
list->add = list_add;
list->destroy = list_destroy;
return list;
}
// -------------------------- 客户端工具函数：统一遍历聚合（核心：不关心聚合类型） --------------------------
void traverse_aggregate(Iterator* iter) {
printf("开始遍历：");
// 统一遍历接口：has_next → next → current
while (iter->has_next(iter)) {
int* data = (int*)iter->current(iter);
printf("%d ", *data);
iter->next(iter);
}
printf("\n");
}
// -------------------------- 测试代码（客户端） --------------------------
int main() {
// 1. 测试数组聚合遍历
ArrayAggregate* array = create_array_aggregate();
int arr_data1 = 10, arr_data2 = 20, arr_data3 = 30;
array->add(array, &arr_data1);
array->add(array, &arr_data2);
array->add(array, &arr_data3);
Iterator* array_iter = array->create_iterator(array);
printf("数组聚合遍历结果：");
traverse_aggregate(array_iter);
array_iter->destroy(array_iter);
array->destroy(array);
// 2. 测试链表聚合遍历（客户端代码完全相同）
ListAggregate* list = create_list_aggregate();
int list_data1 = 100, list_data2 = 200, list_data3 = 300;
list->add(list, &list_data1);
list->add(list, &list_data2);
list->add(list, &list_data3);
Iterator* list_iter = list->create_iterator(list);
printf("链表聚合遍历结果：");
traverse_aggregate(list_iter);
list_iter->destroy(list_iter);
list->destroy(list);
return 0;
}
实现关键要点
1.接口统一核心：Iterator结构体通过函数指针定义has_next/next/current统一接口，无论数组还是链表，客户端都用相同方式遍历。
2.迭代器持有聚合：迭代器的aggregate指针指向聚合对象，确保遍历过程中能访问聚合的数据，无需客户端传递。
3.遍历状态独立：迭代器的state字段存储遍历状态（数组存索引，链表存当前节点），与聚合内部结构解耦，聚合无需记录遍历位置。
4.聚合职责单一：聚合（数组 / 链表）仅负责存储数据和创建迭代器，不关心遍历逻辑，符合 “单一职责原则”。
5.内存管理：迭代器需手动销毁state（如数组的索引、链表的节点指针）和自身，聚合需销毁内部存储（如链表节点），避免内存泄漏。
6.扩展性：新增聚合（如哈希表）时，仅需实现对应的HashIterator和HashAggregate，客户端遍历代码无需修改，符合 “开闭原则”。
C++语言实现（类 + 继承 + 多态 + STL 兼容）
C++ 通过 “抽象基类 + 继承” 定义迭代器和聚合接口，利用多态实现不同聚合的遍历逻辑，同时可兼容 STL 迭代器规范（如++、!=、*运算符重载），使代码更符合 C++ 风格。
#include <iostream>
#include <memory> // 智能指针（自动管理内存）
#include <vector> // 数组聚合内部存储（也可自定义数组）
#include <list> // 链表聚合内部存储（也可自定义链表）
using namespace std;
// -------------------------- 1. 抽象迭代器（Iterator）：统一接口 --------------------------
template <typename T> // 模板支持任意类型元素
class Iterator {
public:
virtual ~Iterator() = default; // 虚析构：确保子类析构被调用
virtual bool hasNext() const = 0; // 是否还有下一个元素
virtual void next() = 0; // 移动到下一个元素
virtual T& current() const = 0; // 获取当前元素
// 重载++运算符（符合STL迭代器习惯）
virtual Iterator<T>& operator++() = 0;
// 重载!=运算符（用于循环判断）
virtual bool operator!=(const Iterator<T>& other) const = 0;
};
// -------------------------- 2. 抽象聚合（Aggregate）：创建迭代器接口 --------------------------
template <typename T>
class Aggregate {
public:
virtual ~Aggregate() = default;
virtual unique_ptr<Iterator<T>> createIterator() = 0; // 创建迭代器（智能指针自动释放）
virtual void add(const T& data) = 0; // 添加元素
virtual size_t size() const = 0; // 获取元素个数
};
// -------------------------- 3. 具体聚合1：数组聚合（ArrayAggregate） --------------------------
template <typename T>
class ArrayAggregate : public Aggregate<T> {
public:
void add(const T& data) override {
data_.push_back(data); // 用vector存储，简化内部实现
}
size_t size() const override {
return data_.size();
}
// 创建数组迭代器
unique_ptr<Iterator<T>> createIterator() override {
return make_unique<ArrayIterator<T>>(this);
}
// 供迭代器访问内部数据（友元或提供getter，这里用友元更简洁）
friend class ArrayIterator<T>;
private:
vector<T> data_; // 内部存储：vector（本质是动态数组）
};
// 数组迭代器（具体迭代器）
template <typename T>
class ArrayIterator : public Iterator<T> {
public:
explicit ArrayIterator(ArrayAggregate<T>* aggregate)
: aggregate_(aggregate), index_(0) {}
bool hasNext() const override {
return index_ < aggregate_->data_.size();
}
void next() override {
if (hasNext()) {
index_++;
}
}
T& current() const override {
if (!hasNext() && index_ == 0) {
throw runtime_error("迭代器未指向任何元素！");
}
return aggregate_->data_[index_ - 1]; // next后index+1，当前元素是index-1
}
// 重载++运算符（前缀++）
Iterator<T>& operator++() override {
next();
return *this;
}
// 重载!=运算符（用于判断是否到达末尾）
bool operator!=(const Iterator<T>& other) const override {
const ArrayIterator<T>* other_iter = dynamic_cast<const ArrayIterator<T>*>(&other);
if (!other_iter) return true; // 不同类型迭代器视为不相等
return index_ != other_iter->index_;
}
private:
ArrayAggregate<T>* aggregate_; // 持有聚合对象
size_t index_; // 遍历状态：当前索引
};
// -------------------------- 4. 具体聚合2：链表聚合（ListAggregate） --------------------------
template <typename T>
class ListAggregate : public Aggregate<T> {
public:
void add(const T& data) override {
data_.push_back(data); // 用list存储，简化内部实现
}
size_t size() const override {
return data_.size();
}
unique_ptr<Iterator<T>> createIterator() override {
return make_unique<ListIterator<T>>(this);
}
friend class ListIterator<T>;
private:
list<T> data_; // 内部存储：list（双向链表）
};
// 链表迭代器（具体迭代器）
template <typename T>
class ListIterator : public Iterator<T> {
public:
explicit ListIterator(ListAggregate<T>* aggregate)
: aggregate_(aggregate), current_iter_(aggregate->data_.begin()) {}
bool hasNext() const override {
return current_iter_ != aggregate_->data_.end();
}
void next() override {
if (hasNext()) {
current_iter_++;
}
}
T& current() const override {
if (!hasNext()) {
throw runtime_error("迭代器未指向任何元素！");
}
return *current_iter_;
}
Iterator<T>& operator++() override {
next();
return *this;
}
bool operator!=(const Iterator<T>& other) const override {
const ListIterator<T>* other_iter = dynamic_cast<const ListIterator<T>*>(&other);
if (!other_iter) return true;
return current_iter_ != other_iter->current_iter_;
}
private:
ListAggregate<T>* aggregate_; // 持有聚合对象
typename list<T>::iterator current_iter_; // 遍历状态：list迭代器
};
// -------------------------- 客户端工具函数：统一遍历聚合（兼容STL风格） --------------------------
template <typename T>
void traverseAggregate(Aggregate<T>& aggregate) {
cout << "开始遍历：";
unique_ptr<Iterator<T>> iter = aggregate.createIterator();
// 方式1：用hasNext()/next()/current()遍历（通用接口）
while (iter->hasNext()) {
cout << iter->current() << " ";
iter->next();
}
cout << endl;
// 方式2：用重载的++/!=遍历（STL风格，更符合C++习惯）
cout << "STL风格遍历：";
unique_ptr<Iterator<T>> begin = aggregate.createIterator();
unique_ptr<Iterator<T>> end = make_unique<ArrayIterator<T>>(nullptr); // 末尾迭代器（占位）
for (; *begin != *end; ++(*begin)) {
cout << begin->current() << " ";
}
cout << endl;
}
// -------------------------- 测试代码（客户端） --------------------------
int main() {
// 1. 测试数组聚合遍历
ArrayAggregate<int> array_agg;
array_agg.add(10);
array_agg.add(20);
array_agg.add(30);
cout << "数组聚合遍历结果：" << endl;
traverseAggregate(array_agg);
// 2. 测试链表聚合遍历（客户端代码完全相同）
ListAggregate<int> list_agg;
list_agg.add(100);
list_agg.add(200);
list_agg.add(300);
cout << "\n链表聚合遍历结果：" << endl;
traverseAggregate(list_agg);
return 0;
}
实现关键要点
1.模板支持泛型：迭代器和聚合用模板定义，支持任意类型元素（如int、string），通用性更强。
2.抽象基类 + 多态：Iterator和Aggregate为抽象基类，具体迭代器 / 聚合继承并实现纯虚函数，客户端依赖抽象，不依赖具体实现，符合 “依赖倒置原则”。
3.STL 风格运算符重载：重载++/!=/*等运算符，使遍历代码更符合 C++ 习惯（如for (; iter != end; ++iter)），可无缝对接 STL 容器。
4.智能指针管理内存：用unique_ptr管理迭代器，自动释放内存，避免手动销毁导致的泄漏，符合 RAII 原则。
5.友元简化访问：具体迭代器通过友元访问聚合的内部存储（如vector/list），无需暴露聚合的getter方法，保证聚合内部封装性。
6.扩展性：新增聚合（如哈希表HashAggregate）时，仅需实现HashIterator和HashAggregate，客户端遍历代码无需修改，完全符合 “开闭原则”。
7.异常处理：迭代器访问越界时抛出异常，增强代码健壮性（C 语言需手动判断返回值）。
迭代器模式核心总结（C vs C++）
设计原则
单一职责原则：聚合管存储，迭代器管遍历，各司其职；
开闭原则：新增聚合或遍历方式，无需修改现有代码；
依赖倒置原则：客户端依赖抽象迭代器 / 聚合，不依赖具体实现。
扫一扫
889
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
