《C++新经典设计模式》之第10章 迭代器模式
迭代器模式.cpp
cpp
#include <iostream>
#include <vector>
#include <list>
#include <memory>
using namespace std;
// 遍历容器中的元素
// 迭代器单独实现为类模板，与容器模板解耦
// 提供一种方法顺序访问一个聚合对象（容器）中各个元素，而又不暴露该对象的内部表示（实现代码）
// 4种角色
// Iterator（抽象迭代器），定义访问和遍历容器中元素的接口
// ConcreteIterator（具体迭代器），具体遍历聚合对象（容器）中元素，记录当前元素位置
// Aggregate（抽象聚合），容器，存储和管理元素对象，声明CreateIterator方法创建迭代器对象，充当创建迭代器的工厂角色
// ConcreteAggregate（具体聚合），返回ConcreteIterator实例
// 单一职责原则
// 一个类的职责应该单一，只做一件事情或者对外只提供一种功能
// 内聚性，功能角度度量模块或类内部组成部分彼此结合紧密程度
// 耦合性，模块间相互关联程度。
// 内容耦合，一个模块直接修改或操作另一个模块的数据
// 公共耦合，多个模块共同引用全局数据项
// 外部耦合，一组模块不是通过参数表访问同一全局简单变量
// 控制耦合，一个模块通过控制信号（传送开关、标志、名字等控制信息），明显地控制另一个模块的功能
// 标记耦合，两个模块间传递数据结构地址
// 数据耦合，模块间通过参数传递数据
// 高类聚、低耦合
namespace ns1
{
template <typename T> // 抽象迭代器类模板
class myIter
{
public:
virtual ~myIter() {}
virtual void First() = 0; // 指向容器中第一个元素
virtual void Next() = 0; // 指向下一个元素
virtual bool IsDone() = 0; // 是否遍历完
virtual T &CurrentItem() = 0; // 获取当前的元素
};
template <typename T> // 抽象容器类模板
class myCotainer
{
public:
virtual ~myCotainer() {}
// virtual myIter<T> *CreateIterator() = 0; // 创建迭代器
virtual shared_ptr<myIter<T>> CreateIterator() = 0; // 创建迭代器
virtual T &getItem(int index) = 0; // 获取当前元素
virtual int getSize() const = 0; // 容器中元素数量
};
template <typename T> // 具体迭代器类模板，针对10元素数组
class myVectorIter : public myIter<T>
{
myCotainer<T> *myvector;
int m_current; // 记录数组的当前下标（迭代器在当前容器中的位置）
public:
myVectorIter(myCotainer<T> *tmpc) : myvector(tmpc), m_current(0) {}
void First() override { m_current = 0; } // 容器（数组）中的第一个元素下标为0
void Next() override { m_current++; } // 下标+1，意味着数组中的下一个元素
bool IsDone() override { return m_current >= myvector->getSize(); }
T &CurrentItem() override { return myvector->getItem(m_current); }
};
template <typename T> // 具体容器类模板
class myVector : public myCotainer<T>
{
private:
T m_elem[10]; // 固定10元素数组
public:
myVector()
{
for (int i = 0; i < 10; ++i)
m_elem[i] = i;
}
// myIter<T> *CreateIterator() override { return new myVectorIter<T>(this); }
shared_ptr<myIter<T>> CreateIterator() override { return make_shared<myVectorIter<T>>(this); }
T &getItem(int index) override { return m_elem[index]; }
int getSize() const override { return 10; }
};
}
int main()
{
#if 0
vector<int> msgVector;
msgVector.push_back(1); // 末尾插入1，vector中内容：1
msgVector.push_back(2); // 末尾插入2，vector中内容：1,2
msgVector.push_back(3); // 末尾插入3，vector中内容：1,2,3
for (vector<int>::const_iterator pos = msgVector.cbegin(); pos != msgVector.cend(); ++pos)
cout << *pos << endl;
cout << "-------------------" << endl;
list<int> msgList;
msgList.push_back(1); // 末尾插入1，list中内容：1
msgList.push_front(2); // 开头插入2，list中内容：2，1
msgList.push_back(3); // 末尾插入3，list中内容：2，1，3
for (list<int>::const_iterator pos = msgList.cbegin(); pos != msgList.cend(); ++pos)
cout << *pos << endl;
#endif
#if 0
using namespace ns1;
shared_ptr<myCotainer<int>> pcontainer(new myVector<int>());
shared_ptr<myIter<int>> iter(pcontainer->CreateIterator());
// 遍历容器中的元素
for (iter->First(); !iter->IsDone(); iter->Next()) // 多态机制的遍历，效率上不好，尽量考虑栈机制
cout << iter->CurrentItem() << endl;
#endif
#if 1
using namespace ns1;
shared_ptr<myCotainer<int>> pcontainer(new myVector<int>());
myVectorIter<int> iter(pcontainer.get());
// 遍历容器中的元素
for (iter.First(); !iter.IsDone(); iter.Next()) // 非多态机制，可以明显改善程序性能
cout << iter.CurrentItem() << endl;
#endif
cout << "Over!\n";
return 0;
}