第十七章：遍历万象，步步为营——Iterator的迭代艺术

第十七章：遍历万象，步步为营------Iterator的迭代艺术

风云再起，迭代游侠登场

在Template Method展示完他那精妙的模板艺术后，Iterator动作流畅、步履轻盈地走出。他的步伐如同行云流水，仿佛能够轻松穿越任何复杂的数据结构。

"Template Method兄的算法骨架确实精妙，"Iterator优雅地说道，"但在集合遍历和元素访问方面，需要更加统一和优雅的方式。诸位请看------"

Iterator身形一晃，瞬间在几个不同的数据结构间穿梭："我的迭代器模式，专为解决集合遍历的统一访问问题而生！我提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示！"

架构老人眼中闪过赞许之色："善！Iterator，就请你为大家展示这迭代艺术的精妙所在。"

迭代器模式的核心要义

Iterator面向众人，开始阐述他的武学真谛：

"在我的迭代器模式中，主要包含四个核心角色："

"Iterator（迭代器）：定义访问和遍历元素的接口。"

"ConcreteIterator（具体迭代器）：实现迭代器接口，跟踪遍历的当前位置。"

"Aggregate（聚合）：定义创建相应迭代器对象的接口。"

"ConcreteAggregate（具体聚合）：实现创建相应迭代器的接口，返回具体迭代器的实例。"

"其精妙之处在于，"Iterator继续道，"我将集合的遍历行为抽象出来，使得客户端无需了解集合的内部结构。这样，我们可以用相同的方式遍历不同的集合，甚至支持多种遍历方式！"

C++实战：多媒体库管理系统

"且让我以一个多媒体库管理系统为例，展示迭代器模式的实战应用。"Iterator说着，手中凝聚出一道道代码流光。

基础框架搭建

首先，Iterator定义了迭代器接口：

#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <algorithm>
#include <map>
#include <iomanip>
#include <sstream>
#include <random>
#include <thread>
#include <chrono>
#include <list>
#include <set>

// 迭代器接口
template<typename T>
class Iterator {
public:
    virtual ~Iterator() = default;
    
    // 重置到第一个元素
    virtual void first() = 0;
    
    // 移动到下一个元素
    virtual void next() = 0;
    
    // 检查是否还有更多元素
    virtual bool isDone() const = 0;
    
    // 获取当前元素
    virtual T currentItem() const = 0;
    
    // 获取当前位置
    virtual int currentPosition() const = 0;
    
    // 便利方法：遍历所有元素
    virtual void traverse(std::function<void(const T&)> visitor) {
        for (first(); !isDone(); next()) {
            visitor(currentItem());
        }
    }
};

// 聚合接口
template<typename T>
class Aggregate {
public:
    virtual ~Aggregate() = default;
    virtual std::unique_ptr<Iterator<T>> createIterator() = 0;
    virtual std::unique_ptr<Iterator<T>> createReverseIterator() = 0;
    virtual int size() const = 0;
    virtual bool isEmpty() const = 0;
};

具体聚合和迭代器实现

Iterator展示了各种数据结构的迭代器实现：

// 具体聚合：数组集合
template<typename T>
class ArrayCollection : public Aggregate<T> {
private:
    std::vector<T> items_;
    std::string name_;
    
public:
    ArrayCollection(const std::string& name = "数组集合") : name_(name) {
        std::cout << "📚 创建数组集合: " << name_ << std::endl;
    }
    
    void add(const T& item) {
        items_.push_back(item);
    }
    
    T& operator[](int index) {
        return items_[index];
    }
    
    const T& operator[](int index) const {
        return items_[index];
    }
    
    std::unique_ptr<Iterator<T>> createIterator() override {
        return std::make_unique<ArrayIterator<T>>(this);
    }
    
    std::unique_ptr<Iterator<T>> createReverseIterator() override {
        return std::make_unique<ReverseArrayIterator<T>>(this);
    }
    
    int size() const override {
        return items_.size();
    }
    
    bool isEmpty() const override {
        return items_.empty();
    }
    
    std::string getName() const {
        return name_;
    }
    
    // 数组集合特有的方法
    void sort() {
        std::sort(items_.begin(), items_.end());
        std::cout << "🔢 对集合 " << name_ << " 进行排序" << std::endl;
    }
    
    void clear() {
        items_.clear();
        std::cout << "🧹 清空集合 " << name_ << std::endl;
    }

private:
    // 具体迭代器：数组迭代器
    class ArrayIterator : public Iterator<T> {
    private:
        const ArrayCollection<T>* collection_;
        int currentIndex_;
        
    public:
        ArrayIterator(const ArrayCollection<T>* collection) 
            : collection_(collection), currentIndex_(0) {
            std::cout << "   🔄 创建数组迭代器" << std::endl;
        }
        
        void first() override {
            currentIndex_ = 0;
        }
        
        void next() override {
            if (!isDone()) {
                currentIndex_++;
            }
        }
        
        bool isDone() const override {
            return currentIndex_ >= collection_->size();
        }
        
        T currentItem() const override {
            if (isDone()) {
                throw std::out_of_range("迭代器已到达末尾");
            }
            return (*collection_)[currentIndex_];
        }
        
        int currentPosition() const override {
            return currentIndex_;
        }
    };
    
    // 具体迭代器：反向数组迭代器
    class ReverseArrayIterator : public Iterator<T> {
    private:
        const ArrayCollection<T>* collection_;
        int currentIndex_;
        
    public:
        ReverseArrayIterator(const ArrayCollection<T>* collection) 
            : collection_(collection), currentIndex_(collection->size() - 1) {
            std::cout << "   🔄 创建反向数组迭代器" << std::endl;
        }
        
        void first() override {
            currentIndex_ = collection_->size() - 1;
        }
        
        void next() override {
            if (!isDone()) {
                currentIndex_--;
            }
        }
        
        bool isDone() const override {
            return currentIndex_ < 0;
        }
        
        T currentItem() const override {
            if (isDone()) {
                throw std::out_of_range("迭代器已到达开头");
            }
            return (*collection_)[currentIndex_];
        }
        
        int currentPosition() const override {
            return currentIndex_;
        }
    };
};

// 具体聚合：链表集合
template<typename T>
class LinkedListCollection : public Aggregate<T> {
private:
    std::list<T> items_;
    std::string name_;
    
public:
    LinkedListCollection(const std::string& name = "链表集合") : name_(name) {
        std::cout << "🔗 创建链表集合: " << name_ << std::endl;
    }
    
    void add(const T& item) {
        items_.push_back(item);
    }
    
    void addFront(const T& item) {
        items_.push_front(item);
    }
    
    std::unique_ptr<Iterator<T>> createIterator() override {
        return std::make_unique<LinkedListIterator<T>>(this);
    }
    
    std::unique_ptr<Iterator<T>> createReverseIterator() override {
        return std::make_unique<ReverseLinkedListIterator<T>>(this);
    }
    
    int size() const override {
        return items_.size();
    }
    
    bool isEmpty() const override {
        return items_.empty();
    }
    
    std::string getName() const {
        return name_;
    }

private:
    // 具体迭代器：链表迭代器
    class LinkedListIterator : public Iterator<T> {
    private:
        const LinkedListCollection<T>* collection_;
        typename std::list<T>::const_iterator current_;
        
    public:
        LinkedListIterator(const LinkedListCollection<T>* collection) 
            : collection_(collection), current_(collection->items_.begin()) {
            std::cout << "   🔄 创建链表迭代器" << std::endl;
        }
        
        void first() override {
            current_ = collection_->items_.begin();
        }
        
        void next() override {
            if (!isDone()) {
                ++current_;
            }
        }
        
        bool isDone() const override {
            return current_ == collection_->items_.end();
        }
        
        T currentItem() const override {
            if (isDone()) {
                throw std::out_of_range("迭代器已到达末尾");
            }
            return *current_;
        }
        
        int currentPosition() const override {
            // 链表没有索引，返回近似位置
            return std::distance(collection_->items_.begin(), current_);
        }
    };
    
    // 具体迭代器：反向链表迭代器
    class ReverseLinkedListIterator : public Iterator<T> {
    private:
        const LinkedListCollection<T>* collection_;
        typename std::list<T>::const_reverse_iterator current_;
        
    public:
        ReverseLinkedListIterator(const LinkedListCollection<T>* collection) 
            : collection_(collection), current_(collection->items_.rbegin()) {
            std::cout << "   🔄 创建反向链表迭代器" << std::endl;
        }
        
        void first() override {
            current_ = collection_->items_.rbegin();
        }
        
        void next() override {
            if (!isDone()) {
                ++current_;
            }
        }
        
        bool isDone() const override {
            return current_ == collection_->items_.rend();
        }
        
        T currentItem() const override {
            if (isDone()) {
                throw std::out_of_range("迭代器已到达开头");
            }
            return *current_;
        }
        
        int currentPosition() const override {
            // 反向位置计算
            return collection_->items_.size() - 1 - 
                   std::distance(collection_->items_.rbegin(), current_);
        }
    };
};

// 具体聚合：集合（不允许重复）
template<typename T>
class SetCollection : public Aggregate<T> {
private:
    std::set<T> items_;
    std::string name_;
    
public:
    SetCollection(const std::string& name = "集合") : name_(name) {
        std::cout << "🔄 创建集合: " << name_ << std::endl;
    }
    
    void add(const T& item) {
        items_.insert(item);
    }
    
    std::unique_ptr<Iterator<T>> createIterator() override {
        return std::make_unique<SetIterator<T>>(this);
    }
    
    std::unique_ptr<Iterator<T>> createReverseIterator() override {
        return std::make_unique<ReverseSetIterator<T>>(this);
    }
    
    int size() const override {
        return items_.size();
    }
    
    bool isEmpty() const override {
        return items_.empty();
    }
    
    std::string getName() const {
        return name_;
    }
    
    // 集合特有的方法
    bool contains(const T& item) const {
        return items_.find(item) != items_.end();
    }
    
    void remove(const T& item) {
        items_.erase(item);
        std::cout << "🗑️  从集合 " << name_ << " 中移除元素" << std::endl;
    }

private:
    // 具体迭代器：集合迭代器
    class SetIterator : public Iterator<T> {
    private:
        const SetCollection<T>* collection_;
        typename std::set<T>::const_iterator current_;
        
    public:
        SetIterator(const SetCollection<T>* collection) 
            : collection_(collection), current_(collection->items_.begin()) {
            std::cout << "   🔄 创建集合迭代器" << std::endl;
        }
        
        void first() override {
            current_ = collection_->items_.begin();
        }
        
        void next() override {
            if (!isDone()) {
                ++current_;
            }
        }
        
        bool isDone() const override {
            return current_ == collection_->items_.end();
        }
        
        T currentItem() const override {
            if (isDone()) {
                throw std::out_of_range("迭代器已到达末尾");
            }
            return *current_;
        }
        
        int currentPosition() const override {
            return std::distance(collection_->items_.begin(), current_);
        }
    };
    
    // 具体迭代器：反向集合迭代器
    class ReverseSetIterator : public Iterator<T> {
    private:
        const SetCollection<T>* collection_;
        typename std::set<T>::const_reverse_iterator current_;
        
    public:
        ReverseSetIterator(const SetCollection<T>* collection) 
            : collection_(collection), current_(collection->items_.rbegin()) {
            std::cout << "   🔄 创建反向集合迭代器" << std::endl;
        }
        
        void first() override {
            current_ = collection_->items_.rbegin();
        }
        
        void next() override {
            if (!isDone()) {
                ++current_;
            }
        }
        
        bool isDone() const override {
            return current_ == collection_->items_.rend();
        }
        
        T currentItem() const override {
            if (isDone()) {
                throw std::out_of_range("迭代器已到达开头");
            }
            return *current_;
        }
        
        int currentPosition() const override {
            return collection_->items_.size() - 1 - 
                   std::distance(collection_->items_.rbegin(), current_);
        }
    };
};

UML 武功秘籍图

creates creates <<interface>> Iterator<T> +first() : void +next() : void +isDone() : bool +currentItem() : T +currentPosition() : int +traverse(function<void(const T&)>) : void <<interface>> Aggregate<T> +createIterator() +createReverseIterator() +size() : int +isEmpty() : bool ArrayCollection<T> -vector<T> items_ -string name_ +add(T) : void +operator[](int) +createIterator() +createReverseIterator() +size() : int +isEmpty() : bool +sort() : void +clear() : void ArrayIterator<T> -const ArrayCollection<T>* collection_ -int currentIndex_ +first() : void +next() : void +isDone() : bool +currentItem() : T +currentPosition() : int LinkedListCollection<T> -list<T> items_ -string name_ +add(T) : void +addFront(T) : void +createIterator() +createReverseIterator() +size() : int +isEmpty() : bool LinkedListIterator<T> -const LinkedListCollection<T>* collection_ -list<T>::const_iterator current_ +first() : void +next() : void +isDone() : bool +currentItem() : T +currentPosition() : int

实战演练：高级迭代系统

Iterator继续展示更复杂的迭代器模式应用：

// 过滤迭代器：基于条件的元素过滤
template<typename T>
class FilterIterator : public Iterator<T> {
private:
    std::unique_ptr<Iterator<T>> baseIterator_;
    std::function<bool(const T&)> predicate_;
    T currentItem_;
    bool isValid_;
    
public:
    FilterIterator(std::unique_ptr<Iterator<T>> baseIterator, 
                   std::function<bool(const T&)> predicate)
        : baseIterator_(std::move(baseIterator)), predicate_(predicate) {
        std::cout << "🎯 创建过滤迭代器" << std::endl;
        findNextValid();
    }
    
    void first() override {
        baseIterator_->first();
        findNextValid();
    }
    
    void next() override {
        if (!isDone()) {
            baseIterator_->next();
            findNextValid();
        }
    }
    
    bool isDone() const override {
        return !isValid_;
    }
    
    T currentItem() const override {
        if (isDone()) {
            throw std::out_of_range("迭代器已到达末尾");
        }
        return currentItem_;
    }
    
    int currentPosition() const override {
        return baseIterator_->currentPosition();
    }
    
private:
    void findNextValid() {
        isValid_ = false;
        while (!baseIterator_->isDone()) {
            T item = baseIterator_->currentItem();
            if (predicate_(item)) {
                currentItem_ = item;
                isValid_ = true;
                break;
            }
            baseIterator_->next();
        }
    }
};

// 转换迭代器：对元素进行转换
template<typename T, typename U>
class TransformIterator : public Iterator<U> {
private:
    std::unique_ptr<Iterator<T>> baseIterator_;
    std::function<U(const T&)> transformer_;
    
public:
    TransformIterator(std::unique_ptr<Iterator<T>> baseIterator, 
                      std::function<U(const T&)> transformer)
        : baseIterator_(std::move(baseIterator)), transformer_(transformer) {
        std::cout << "🔄 创建转换迭代器" << std::endl;
    }
    
    void first() override {
        baseIterator_->first();
    }
    
    void next() override {
        baseIterator_->next();
    }
    
    bool isDone() const override {
        return baseIterator_->isDone();
    }
    
    U currentItem() const override {
        if (isDone()) {
            throw std::out_of_range("迭代器已到达末尾");
        }
        return transformer_(baseIterator_->currentItem());
    }
    
    int currentPosition() const override {
        return baseIterator_->currentPosition();
    }
};

// 分页迭代器：支持分页遍历
template<typename T>
class PagedIterator : public Iterator<T> {
private:
    std::unique_ptr<Iterator<T>> baseIterator_;
    int pageSize_;
    int currentPage_;
    std::vector<T> currentPageItems_;
    int pageIndex_;
    
public:
    PagedIterator(std::unique_ptr<Iterator<T>> baseIterator, int pageSize)
        : baseIterator_(std::move(baseIterator)), pageSize_(pageSize), 
          currentPage_(0), pageIndex_(0) {
        std::cout << "📄 创建分页迭代器，页大小: " << pageSize_ << std::endl;
        loadNextPage();
    }
    
    void first() override {
        baseIterator_->first();
        currentPage_ = 0;
        loadNextPage();
    }
    
    void next() override {
        if (!isDone()) {
            pageIndex_++;
            if (pageIndex_ >= currentPageItems_.size()) {
                loadNextPage();
            }
        }
    }
    
    bool isDone() const override {
        return currentPageItems_.empty();
    }
    
    T currentItem() const override {
        if (isDone()) {
            throw std::out_of_range("迭代器已到达末尾");
        }
        return currentPageItems_[pageIndex_];
    }
    
    int currentPosition() const override {
        return currentPage_ * pageSize_ + pageIndex_;
    }
    
    int getCurrentPage() const {
        return currentPage_;
    }
    
    int getPageCount() const {
        // 简化实现，实际需要知道总元素数
        return -1;
    }
    
private:
    void loadNextPage() {
        currentPageItems_.clear();
        pageIndex_ = 0;
        
        int count = 0;
        while (!baseIterator_->isDone() && count < pageSize_) {
            currentPageItems_.push_back(baseIterator_->currentItem());
            baseIterator_->next();
            count++;
        }
        
        if (!currentPageItems_.empty()) {
            currentPage_++;
            std::cout << "   📖 加载第 " << currentPage_ << " 页，包含 " 
                      << currentPageItems_.size() << " 个元素" << std::endl;
        }
    }
};

// 复合迭代器：合并多个迭代器
template<typename T>
class CompositeIterator : public Iterator<T> {
private:
    std::vector<std::unique_ptr<Iterator<T>>> iterators_;
    size_t currentIteratorIndex_;
    
public:
    CompositeIterator() : currentIteratorIndex_(0) {
        std::cout << "🧩 创建复合迭代器" << std::endl;
    }
    
    void addIterator(std::unique_ptr<Iterator<T>> iterator) {
        iterators_.push_back(std::move(iterator));
    }
    
    void first() override {
        currentIteratorIndex_ = 0;
        for (auto& iterator : iterators_) {
            iterator->first();
        }
    }
    
    void next() override {
        if (isDone()) return;
        
        if (!iterators_[currentIteratorIndex_]->isDone()) {
            iterators_[currentIteratorIndex_]->next();
        }
        
        // 如果当前迭代器结束，移动到下一个
        while (currentIteratorIndex_ < iterators_.size() && 
               iterators_[currentIteratorIndex_]->isDone()) {
            currentIteratorIndex_++;
        }
    }
    
    bool isDone() const override {
        return currentIteratorIndex_ >= iterators_.size();
    }
    
    T currentItem() const override {
        if (isDone()) {
            throw std::out_of_range("迭代器已到达末尾");
        }
        return iterators_[currentIteratorIndex_]->currentItem();
    }
    
    int currentPosition() const override {
        if (isDone()) {
            return -1;
        }
        
        int position = 0;
        for (size_t i = 0; i < currentIteratorIndex_; i++) {
            // 计算前面迭代器的总元素数（简化实现）
            position += 100; // 假设每个迭代器有100个元素
        }
        
        return position + iterators_[currentIteratorIndex_]->currentPosition();
    }
    
    size_t getCurrentSourceIndex() const {
        return currentIteratorIndex_;
    }
};

多媒体数据模型

// 多媒体文件类
class MediaFile {
private:
    std::string filename_;
    std::string type_; // "audio", "video", "image"
    int size_; // KB
    int duration_; // seconds
    int rating_; // 1-5
    
public:
    MediaFile(const std::string& filename, const std::string& type, 
              int size = 0, int duration = 0, int rating = 3)
        : filename_(filename), type_(type), size_(size), 
          duration_(duration), rating_(rating) {}
    
    std::string getFilename() const { return filename_; }
    std::string getType() const { return type_; }
    int getSize() const { return size_; }
    int getDuration() const { return duration_; }
    int getRating() const { return rating_; }
    
    void setRating(int rating) {
        rating_ = std::max(1, std::min(5, rating));
    }
    
    std::string toString() const {
        std::stringstream ss;
        ss << filename_ << " [" << type_ << ", " << size_ << "KB, " 
           << duration_ << "s, 评分:" << rating_ << "/5]";
        return ss.str();
    }
    
    // 用于集合比较
    bool operator<(const MediaFile& other) const {
        return filename_ < other.filename_;
    }
    
    bool operator==(const MediaFile& other) const {
        return filename_ == other.filename_;
    }
};

// 多媒体库类
class MediaLibrary {
private:
    ArrayCollection<MediaFile> audioFiles_;
    ArrayCollection<MediaFile> videoFiles_;
    ArrayCollection<MediaFile> imageFiles_;
    SetCollection<MediaFile> favoriteFiles_;
    
public:
    MediaLibrary() 
        : audioFiles_("音频文件"), videoFiles_("视频文件"), 
          imageFiles_("图片文件"), favoriteFiles_("收藏文件") {
        std::cout << "🏛️  创建多媒体库" << std::endl;
        initializeSampleData();
    }
    
    void initializeSampleData() {
        // 添加示例数据
        audioFiles_.add(MediaFile("song1.mp3", "audio", 5120, 180, 4));
        audioFiles_.add(MediaFile("song2.mp3", "audio", 6144, 210, 5));
        audioFiles_.add(MediaFile("podcast1.mp3", "audio", 10240, 3600, 3));
        
        videoFiles_.add(MediaFile("movie1.mp4", "video", 1048576, 7200, 5));
        videoFiles_.add(MediaFile("clip1.mp4", "video", 51200, 180, 4));
        videoFiles_.add(MediaFile("documentary1.mp4", "video", 2097152, 5400, 4));
        
        imageFiles_.add(MediaFile("photo1.jpg", "image", 2048, 0, 3));
        imageFiles_.add(MediaFile("photo2.jpg", "image", 3072, 0, 5));
        imageFiles_.add(MediaFile("screenshot1.png", "image", 1024, 0, 2));
        
        // 添加一些收藏
        favoriteFiles_.add(MediaFile("song2.mp3", "audio", 6144, 210, 5));
        favoriteFiles_.add(MediaFile("movie1.mp4", "video", 1048576, 7200, 5));
        favoriteFiles_.add(MediaFile("photo2.jpg", "image", 3072, 0, 5));
        
        std::cout << "✅ 多媒体库初始化完成" << std::endl;
    }
    
    // 获取各种迭代器
    std::unique_ptr<Iterator<MediaFile>> getAllFilesIterator() {
        auto composite = std::make_unique<CompositeIterator<MediaFile>>();
        composite->addIterator(audioFiles_.createIterator());
        composite->addIterator(videoFiles_.createIterator());
        composite->addIterator(imageFiles_.createIterator());
        return composite;
    }
    
    std::unique_ptr<Iterator<MediaFile>> getAudioFilesIterator() {
        return audioFiles_.createIterator();
    }
    
    std::unique_ptr<Iterator<MediaFile>> getVideoFilesIterator() {
        return videoFiles_.createIterator();
    }
    
    std::unique_ptr<Iterator<MediaFile>> getImageFilesIterator() {
        return imageFiles_.createIterator();
    }
    
    std::unique_ptr<Iterator<MediaFile>> getFavoriteFilesIterator() {
        return favoriteFiles_.createIterator();
    }
    
    std::unique_ptr<Iterator<MediaFile>> getHighRatedFilesIterator(int minRating = 4) {
        auto allFiles = getAllFilesIterator();
        return std::make_unique<FilterIterator<MediaFile>>(
            std::move(allFiles),
            [minRating](const MediaFile& file) {
                return file.getRating() >= minRating;
            }
        );
    }
    
    std::unique_ptr<Iterator<MediaFile>> getLargeFilesIterator(int minSizeKB = 10240) {
        auto allFiles = getAllFilesIterator();
        return std::make_unique<FilterIterator<MediaFile>>(
            std::move(allFiles),
            [minSizeKB](const MediaFile& file) {
                return file.getSize() >= minSizeKB;
            }
        );
    }
    
    std::unique_ptr<Iterator<std::string>> getFilenamesIterator() {
        auto allFiles = getAllFilesIterator();
        return std::make_unique<TransformIterator<MediaFile, std::string>>(
            std::move(allFiles),
            [](const MediaFile& file) {
                return file.getFilename();
            }
        );
    }
    
    std::unique_ptr<Iterator<MediaFile>> getPagedIterator(int pageSize = 2) {
        auto allFiles = getAllFilesIterator();
        return std::make_unique<PagedIterator<MediaFile>>(
            std::move(allFiles), pageSize
        );
    }
    
    // 统计信息
    void showLibraryStats() {
        std::cout << "\n📊 多媒体库统计信息:" << std::endl;
        std::cout << "   音频文件: " << audioFiles_.size() << " 个" << std::endl;
        std::cout << "   视频文件: " << videoFiles_.size() << " 个" << std::endl;
        std::cout << "   图片文件: " << imageFiles_.size() << " 个" << std::endl;
        std::cout << "   收藏文件: " << favoriteFiles_.size() << " 个" << std::endl;
        
        int totalSize = 0;
        auto iterator = getAllFilesIterator();
        iterator->traverse([&totalSize](const MediaFile& file) {
            totalSize += file.getSize();
        });
        
        std::cout << "   总大小: " << (totalSize / 1024.0) << " MB" << std::endl;
    }
    
    // 添加新文件
    void addMediaFile(const MediaFile& file) {
        if (file.getType() == "audio") {
            audioFiles_.add(file);
        } else if (file.getType() == "video") {
            videoFiles_.add(file);
        } else if (file.getType() == "image") {
            imageFiles_.add(file);
        }
        std::cout << "➕ 添加文件: " << file.getFilename() << std::endl;
    }
    
    // 添加到收藏
    void addToFavorites(const MediaFile& file) {
        favoriteFiles_.add(file);
        std::cout << "⭐ 添加到收藏: " << file.getFilename() << std::endl;
    }
};

完整测试代码

// 测试迭代器模式
void testIteratorPattern() {
    std::cout << "=== 迭代器模式测试开始 ===" << std::endl;
    
    // 创建数组集合并测试
    std::cout << "\n--- 数组集合测试 ---" << std::endl;
    ArrayCollection<int> numbers("数字集合");
    for (int i = 1; i <= 5; i++) {
        numbers.add(i * 10);
    }
    
    auto iterator = numbers.createIterator();
    std::cout << "正向遍历:" << std::endl;
    iterator->traverse([](const int& num) {
        std::cout << "   " << num << std::endl;
    });
    
    auto reverseIterator = numbers.createReverseIterator();
    std::cout << "反向遍历:" << std::endl;
    reverseIterator->traverse([](const int& num) {
        std::cout << "   " << num << std::endl;
    });
    
    // 创建链表集合并测试
    std::cout << "\n--- 链表集合测试 ---" << std::endl;
    LinkedListCollection<std::string> names("名字集合");
    names.add("张三");
    names.add("李四");
    names.add("王五");
    names.addFront("赵六"); // 添加到前面
    
    auto nameIterator = names.createIterator();
    std::cout << "名字遍历:" << std::endl;
    nameIterator->traverse([](const std::string& name) {
        std::cout << "   " << name << std::endl;
    });
    
    // 创建集合并测试
    std::cout << "\n--- 集合测试 ---" << std::endl;
    SetCollection<int> uniqueNumbers("唯一数字集合");
    uniqueNumbers.add(10);
    uniqueNumbers.add(20);
    uniqueNumbers.add(10); // 重复，不会被添加
    uniqueNumbers.add(30);
    
    auto setIterator = uniqueNumbers.createIterator();
    std::cout << "唯一数字遍历:" << std::endl;
    setIterator->traverse([](const int& num) {
        std::cout << "   " << num << std::endl;
    });
    
    std::cout << "\n=== 基础迭代器模式测试结束 ===" << std::endl;
}

// 测试高级迭代器
void testAdvancedIterators() {
    std::cout << "\n=== 高级迭代器测试开始 ===" << std::endl;
    
    // 创建测试数据
    ArrayCollection<int> numbers("测试数字");
    for (int i = 1; i <= 10; i++) {
        numbers.add(i);
    }
    
    // 测试过滤迭代器
    std::cout << "\n--- 过滤迭代器测试 ---" << std::endl;
    auto baseIterator = numbers.createIterator();
    auto evenIterator = std::make_unique<FilterIterator<int>>(
        std::move(baseIterator),
        [](const int& num) { return num % 2 == 0; }
    );
    
    std::cout << "偶数数字:" << std::endl;
    evenIterator->traverse([](const int& num) {
        std::cout << "   " << num << std::endl;
    });
    
    // 测试转换迭代器
    std::cout << "\n--- 转换迭代器测试 ---" << std::endl;
    baseIterator = numbers.createIterator();
    auto squaredIterator = std::make_unique<TransformIterator<int, int>>(
        std::move(baseIterator),
        [](const int& num) { return num * num; }
    );
    
    std::cout << "数字平方:" << std::endl;
    squaredIterator->traverse([](const int& num) {
        std::cout << "   " << num << std::endl;
    });
    
    // 测试分页迭代器
    std::cout << "\n--- 分页迭代器测试 ---" << std::endl;
    baseIterator = numbers.createIterator();
    auto pagedIterator = std::make_unique<PagedIterator<int>>(
        std::move(baseIterator), 3
    );
    
    std::cout << "分页遍历:" << std::endl;
    pagedIterator->traverse([](const int& num) {
        std::cout << "   " << num << " (第" 
                  << dynamic_cast<PagedIterator<int>&>(*pagedIterator).getCurrentPage() 
                  << "页)" << std::endl;
    });
    
    // 测试复合迭代器
    std::cout << "\n--- 复合迭代器测试 ---" << std::endl;
    ArrayCollection<int> collection1("集合1");
    ArrayCollection<int> collection2("集合2");
    
    collection1.add(100);
    collection1.add(200);
    collection2.add(300);
    collection2.add(400);
    
    auto compositeIterator = std::make_unique<CompositeIterator<int>>();
    compositeIterator->addIterator(collection1.createIterator());
    compositeIterator->addIterator(collection2.createIterator());
    
    std::cout << "复合遍历:" << std::endl;
    compositeIterator->traverse([](const int& num) {
        std::cout << "   " << num << std::endl;
    });
    
    std::cout << "\n=== 高级迭代器测试结束 ===" << std::endl;
}

// 测试多媒体库
void testMediaLibrary() {
    std::cout << "\n=== 多媒体库测试开始 ===" << std::endl;
    
    MediaLibrary library;
    
    // 显示库统计
    library.showLibraryStats();
    
    // 测试各种迭代器
    std::cout << "\n--- 所有文件遍历 ---" << std::endl;
    auto allIterator = library.getAllFilesIterator();
    allIterator->traverse([](const MediaFile& file) {
        std::cout << "   " << file.toString() << std::endl;
    });
    
    std::cout << "\n--- 高评分文件遍历 (评分>=4) ---" << std::endl;
    auto highRatedIterator = library.getHighRatedFilesIterator(4);
    highRatedIterator->traverse([](const MediaFile& file) {
        std::cout << "   " << file.toString() << std::endl;
    });
    
    std::cout << "\n--- 大文件遍历 (>=10MB) ---" << std::endl;
    auto largeFilesIterator = library.getLargeFilesIterator(10240);
    largeFilesIterator->traverse([](const MediaFile& file) {
        std::cout << "   " << file.toString() << std::endl;
    });
    
    std::cout << "\n--- 仅文件名遍历 ---" << std::endl;
    auto filenamesIterator = library.getFilenamesIterator();
    filenamesIterator->traverse([](const std::string& filename) {
        std::cout << "   " << filename << std::endl;
    });
    
    std::cout << "\n--- 分页遍历 (每页2个) ---" << std::endl;
    auto pagedIterator = library.getPagedIterator(2);
    pagedIterator->traverse([](const MediaFile& file) {
        std::cout << "   " << file.toString() << std::endl;
    });
    
    std::cout << "\n=== 多媒体库测试结束 ===" << std::endl;
}

// 实战应用：智能媒体播放器
class SmartMediaPlayer {
private:
    MediaLibrary library_;
    std::vector<MediaFile> playHistory_;
    std::vector<MediaFile> playQueue_;
    
public:
    SmartMediaPlayer() {
        std::cout << "🎵 创建智能媒体播放器" << std::endl;
    }
    
    void playAll() {
        std::cout << "\n🎶 播放所有媒体文件..." << std::endl;
        auto iterator = library_.getAllFilesIterator();
        
        iterator->traverse([this](const MediaFile& file) {
            playFile(file);
        });
        
        std::cout << "✅ 所有文件播放完成" << std::endl;
    }
    
    void playHighRated(int minRating = 4) {
        std::cout << "\n⭐ 播放高评分文件 (评分>=" << minRating << ")..." << std::endl;
        auto iterator = library_.getHighRatedFilesIterator(minRating);
        
        iterator->traverse([this](const MediaFile& file) {
            playFile(file);
        });
    }
    
    void playByType(const std::string& type) {
        std::cout << "\n🎯 播放类型: " << type << "..." << std::endl;
        
        std::unique_ptr<Iterator<MediaFile>> iterator;
        if (type == "audio") {
            iterator = library_.getAudioFilesIterator();
        } else if (type == "video") {
            iterator = library_.getVideoFilesIterator();
        } else if (type == "image") {
            iterator = library_.getImageFilesIterator();
        } else {
            std::cout << "❌ 未知媒体类型: " << type << std::endl;
            return;
        }
        
        iterator->traverse([this](const MediaFile& file) {
            playFile(file);
        });
    }
    
    void playFavorites() {
        std::cout << "\n❤️  播放收藏文件..." << std::endl;
        auto iterator = library_.getFavoriteFilesIterator();
        
        iterator->traverse([this](const MediaFile& file) {
            playFile(file);
        });
    }
    
    void createPlaylist(const std::string& name, std::function<bool(const MediaFile&)> criteria) {
        std::cout << "\n📝 创建播放列表: " << name << "..." << std::endl;
        auto allFiles = library_.getAllFilesIterator();
        auto playlistIterator = std::make_unique<FilterIterator<MediaFile>>(
            std::move(allFiles), criteria
        );
        
        int count = 0;
        playlistIterator->traverse([this, &count](const MediaFile& file) {
            playQueue_.push_back(file);
            count++;
        });
        
        std::cout << "✅ 播放列表 '" << name << "' 创建完成，包含 " << count << " 个文件" << std::endl;
    }
    
    void playQueue() {
        std::cout << "\n▶️  播放队列中的文件..." << std::endl;
        for (const auto& file : playQueue_) {
            playFile(file);
        }
        playQueue_.clear();
    }
    
    void showPlayHistory() {
        std::cout << "\n📜 播放历史 (" << playHistory_.size() << " 个文件):" << std::endl;
        for (const auto& file : playHistory_) {
            std::cout << "   " << file.toString() << std::endl;
        }
    }
    
    void runDemo() {
        std::cout << "\n🎮 运行智能媒体播放器演示..." << std::endl;
        std::cout << "==========================" << std::endl;
        
        // 显示库信息
        library_.showLibraryStats();
        
        // 播放各种内容
        playByType("audio");
        playHighRated(5);
        
        // 创建自定义播放列表
        createPlaylist("大型视频文件", [](const MediaFile& file) {
            return file.getType() == "video" && file.getSize() > 500000;
        });
        
        playQueue();
        
        // 显示播放历史
        showPlayHistory();
    }
    
private:
    void playFile(const MediaFile& file) {
        std::cout << "   ▶️  播放: " << file.getFilename() << std::endl;
        
        // 模拟播放过程
        if (file.getType() == "audio" || file.getType() == "video") {
            std::cout << "      ⏱️  时长: " << file.getDuration() << "秒" << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        } else {
            std::cout << "      🖼️  显示图片" << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }
        
        // 记录播放历史
        playHistory_.push_back(file);
    }
};

// 高级应用：迭代器工具类
class IteratorUtils {
public:
    // 统计元素数量
    template<typename T>
    static int count(std::unique_ptr<Iterator<T>> iterator) {
        int count = 0;
        iterator->traverse([&count](const T&) { count++; });
        return count;
    }
    
    // 查找元素
    template<typename T>
    static std::optional<T> find(std::unique_ptr<Iterator<T>> iterator, 
                                std::function<bool(const T&)> predicate) {
        for (iterator->first(); !iterator->isDone(); iterator->next()) {
            if (predicate(iterator->currentItem())) {
                return iterator->currentItem();
            }
        }
        return std::nullopt;
    }
    
    // 转换为向量
    template<typename T>
    static std::vector<T> toVector(std::unique_ptr<Iterator<T>> iterator) {
        std::vector<T> result;
        iterator->traverse([&result](const T& item) {
            result.push_back(item);
        });
        return result;
    }
    
    // 应用函数到每个元素
    template<typename T>
    static void forEach(std::unique_ptr<Iterator<T>> iterator, 
                       std::function<void(const T&)> action) {
        iterator->traverse(action);
    }
    
    // 检查所有元素是否满足条件
    template<typename T>
    static bool allMatch(std::unique_ptr<Iterator<T>> iterator, 
                        std::function<bool(const T&)> predicate) {
        for (iterator->first(); !iterator->isDone(); iterator->next()) {
            if (!predicate(iterator->currentItem())) {
                return false;
            }
        }
        return true;
    }
    
    // 检查是否有元素满足条件
    template<typename T>
    static bool anyMatch(std::unique_ptr<Iterator<T>> iterator, 
                        std::function<bool(const T&)> predicate) {
        for (iterator->first(); !iterator->isDone(); iterator->next()) {
            if (predicate(iterator->currentItem())) {
                return true;
            }
        }
        return false;
    }
};

int main() {
    std::cout << "🌈 设计模式武林大会 - 迭代器模式演示 🌈" << std::endl;
    std::cout << "=====================================" << std::endl;
    
    // 测试基础迭代器模式
    testIteratorPattern();
    
    // 测试高级迭代器
    testAdvancedIterators();
    
    // 测试多媒体库
    testMediaLibrary();
    
    // 运行智能媒体播放器演示
    std::cout << "\n=== 智能媒体播放器演示 ===" << std::endl;
    SmartMediaPlayer player;
    player.runDemo();
    
    // 测试迭代器工具类
    std::cout << "\n=== 迭代器工具类测试 ===" << std::endl;
    ArrayCollection<int> testCollection("测试工具类");
    for (int i = 1; i <= 5; i++) {
        testCollection.add(i);
    }
    
    auto testIterator = testCollection.createIterator();
    std::cout << "元素数量: " << IteratorUtils::count<int>(std::move(testIterator)) << std::endl;
    
    testIterator = testCollection.createIterator();
    auto found = IteratorUtils::find<int>(std::move(testIterator), 
        [](int num) { return num > 3; });
    if (found) {
        std::cout << "找到元素: " << found.value() << std::endl;
    }
    
    std::cout << "\n🎉 迭代器模式演示全部完成!" << std::endl;
    
    return 0;
}

迭代器模式的武学心得

适用场景

• 统一遍历接口：当需要为不同的聚合结构提供统一的遍历方式时
• 隐藏内部结构：当不希望暴露聚合对象的内部表示时
• 支持多种遍历：当需要支持多种遍历方式（正序、逆序、过滤等）时
• 简化客户端代码：当希望简化客户端的遍历代码时

优点

• 简化聚合接口：聚合对象不需要包含遍历代码
• 支持多种遍历：可以轻松实现不同的遍历算法
• 封装性良好：将遍历逻辑封装在迭代器中，不暴露聚合内部
• 开闭原则：可以增加新的迭代器而不修改聚合类
• 并行遍历：可以同时使用多个迭代器遍历同一聚合

缺点

• 增加系统复杂度：每个聚合都需要对应的迭代器类
• 可能降低性能：迭代器调用可能比直接访问稍慢
• 修改聚合困难：如果在遍历过程中修改聚合，迭代器可能失效

武林高手的点评

Composite 赞叹道："Iterator 兄的遍历统一确实精妙！能够如此优雅地处理各种数据结构的遍历，这在需要操作复杂集合的系统中确实无人能及。"

Visitor 也点头称赞："Iterator 兄专注于元素的遍历访问，而我更关注对元素的操作。我们都涉及集合元素的处理，但关注点不同。"

Iterator 谦虚回应："诸位过奖了。每个模式都有其适用场景。在需要统一遍历集合元素时，我的迭代器模式确实能发挥重要作用。但在需要对元素执行特定操作时，Visitor 兄的方法更加合适。"

下章预告

在Iterator展示完他那精妙的迭代艺术后，Chain of Responsibility 几位高手手挽手，连成一条长链走来。

"Iterator 兄的遍历统一确实精妙，但在请求处理和职责传递方面，需要更加灵活的链式处理方式。" Chain of Responsibility 为首者说道，"下一章，我们将展示如何通过责任链模式将请求的发送者与接收者解耦，让多个对象都有机会处理请求！"

架构老人满意地点头："善！请求的链式处理确实是构建灵活系统的关键。下一章，就请 Chain of Responsibility 展示他的责任链艺术！"

---

欲知 Chain of Responsibility 如何通过责任链模式实现请求的灵活处理，且听下回分解！