C++迭代器模式：Iterator Pattern

迭代器模式，提供一种统一的方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

案例：各个学院有不同的专业，假如计算机学院用数组存储不同的专业，然而数学学院是用链表存储的，其他的学院可能还使用其他不同的数据结构来存储。客户端要遍历各个学院的所有专业就很麻烦，不同的数据类型需要不同的方式来遍历。不同专业的类型都是字符串类型，但是存储的数据结构不同。

假设计算机学院使用数组存储，数学学院使用链表存储。把数组和链表的不同遍历方式封装到hasNext和next函数中，用户看不出其他的不同。（hasNext和next函数的多态）

使用迭代器模式就可以把这些差异给统一起来，便于遍历。

类图：

实现如下：

myIterator.h：

#ifndef ITERATOR_H
#define ITERATOR_H
#include <iostream>
#include <string>
#include <vector>
#include <list>
using namespace std;

class MyIterator {
public:
    virtual bool hasNext() = 0;
    virtual string next() = 0;
};

#endif // ITERATOR_H

computerIterator.h：

#ifndef COMPUTERITERATOR_H
#define COMPUTERITERATOR_H
#include "myIterator.h"
#include "computerMajor.h"

class ComputerIterator : public MyIterator {
public:
    ComputerIterator(vector<string> v);
    virtual bool hasNext() override;
    virtual string next() override;
private:
    vector<string> m_majors;
    int m_idx = 0;
};

ComputerIterator::ComputerIterator(vector<string> v)
{
    m_majors  = v;
}

bool ComputerIterator::hasNext()
{
    if(m_idx <= m_majors.size())
    {
        return true;
    }
    else return false;
}

string ComputerIterator::next()
{
    if(hasNext()) return m_majors[ m_idx++ ];
}


#endif // COMPUTERITERATOR_H

mathIterator.h：

#ifndef MATHITERATOR_H
#define MATHITERATOR_H
#include "myIterator.h"
#include "mathMajor.h"

class MathIterator : public MyIterator {
public:
    MathIterator(list<string> l);
    virtual bool hasNext() override;
    virtual string next() override;
private:
    list<string> m_majors;
    int m_idx = 0;
};

MathIterator::MathIterator(list<string> l)
{
    m_majors  = l;
}

bool MathIterator::hasNext()
{
    if(m_idx <= m_majors.size())
    {
        return true;
    }
    else return false;
}

string MathIterator::next()
{
    if(hasNext())
    {
        m_idx ++ ;
        string major = m_majors.front();
        m_majors.pop_front(); // 删除第一次元素
        return major;
    }
}

#endif // MATHITERATOR_H

major.h：

#ifndef MAJOR_H
#define MAJOR_H
#include "myIterator.h"

class Major {
public:
    virtual MyIterator* createIterator() = 0;
};

#endif // MAJOR_H

computerMajor.h：    

#ifndef COMPUTERMAJOR_H
#define COMPUTERMAJOR_H
#include "major.h"
#include "computerIterator.h"


class ComputerMajor : public Major {
public:
    virtual MyIterator* createIterator() override;

    vector<string> m_majors = {"软件工程", "人工智能"};
};

MyIterator* ComputerMajor::createIterator()
{
    return new ComputerIterator(m_majors);
}

#endif // COMPUTERMAJOR_H

mathMajor.h：

#ifndef MATHMAJOR_H
#define MATHMAJOR_H
#include "major.h"
#include "mathIterator.h"


class MathMajor : public Major {
public:
    virtual MyIterator* createIterator() override;

    list<string> m_majors = {"应用数学", "数学类"};
    };

    MyIterator* MathMajor::createIterator()
    {
        return new MathIterator(m_majors);
    }
#endif // MATHMAJOR_H

main.cpp：

/*
 * 迭代器模式
 *
 * date:2023-9-14
*/

#include "computerMajor.h"
#include "mathMajor.h"

void printMajor(MyIterator* myIteraor)
{
    while (myIteraor->hasNext())  cout << myIteraor->next() << endl;
}



int main()
{
    cout << "数学学院的专业有： " << endl;

    Major* major = new MathMajor();
    MyIterator* myIterator = major->createIterator();
    printMajor(myIterator);

    cout << endl;

    cout << "计算机学院的专业有：" << endl;
    major = new ComputerMajor();
    myIterator = major->createIterator();
    printMajor(myIterator);


}

运行结果：