//---------------------------15/04/26----------------------------
//Iterator 迭代器模式----对象行为型模式
/*
1:意图：
提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。
2:别名：
游标(Cursor)
3:动机：
4:适用性：
1>访问一个聚合对象的内容而无需暴露它的内部表示。
2>支持对聚合对象的多种遍历。
3>为遍历不同的聚合结构提供一个统一的接口。
5:结构：
Aggregate:<-------------Client----------------->Iterator:
CreateIterator() First()
| Next()
| IsDone()
| CurrentItem()
| |
ConcreteAggregate()- - - - - - - - - - - - - ->ConcreteIterator
CreateIterator() <------------------------------|
{ return new ConcreteIterator(this)}
6:参与者：
1>Iterator：
迭代器定义访问和遍历元素的接口。
2>ConcreteIterator：
1)具体迭代器实现迭代器接口。
2)对该聚合遍历时跟踪当前位置。
3>Aggregate：
聚合定义创建相应迭代器对象的接口。
4>ConcreteAggregate：
具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。
7:协作：
ConcreteIterator跟踪聚合中的当前对象，并能够计算出代遍历的后继对象。
8:效果：
1>它支持以不同的方式遍历一个聚合：
复杂的聚合可用多种方式进行遍历。比如stl中的正常的迭代器以及反向迭代器。
2>迭代器简化了聚合的接口：
有了迭代器的遍历接口，聚合本身就不再需要类似的遍历接口，这样就简化了聚合的接口。
3>在同一个聚合上可以有多个遍历：
每个迭代器保持它自己的遍历状态。因此你可以同时进行多个遍历。
9:实现：
迭代器在实现上有许多变化和选择。
1>谁控制该迭代：
由客户来控制迭代的称为外部迭代器，由迭代器控制迭代称为内部迭代器。外部迭代器比较灵活
内部迭代器实现起来比较简单。所以能实现还是实现为外部迭代器的。
2>谁定义遍历算法：
迭代器来负责遍历算法易于在相同聚合上使用不同的迭代算法，也易于在不同的聚合上重用相同的算法。
但是因为要访问聚合中的私有变量，会破坏聚合的封装性
3>迭代器健壮程度如何：
插入和删除操作不能干扰别的迭代器的遍历。为了速度考虑，stl的迭代器并不都能保证这个条件。
4>附加的迭代器操作：
迭代器起码要有First,Next,IsDone,CurrenItem等操作，当然可以附加一些有用的操作，比如
Previous
5>在c++中使用多态的迭代器：
使用多态的迭代器是要付出代价的，也就是客户必须自己删除迭代器指针，所以可以使用智能指针
也就是代理模式。
6>迭代器可有特权访问：
迭代器可以访问聚合的元素，所以可以声明为友元，为了防止多次声明友元，可以定义一个abstract
的迭代器，然后由只要继承这个类就能行了。
7>用于复合对象的迭代器：
在Composite模式中，那些递归聚合结构上，外部迭代器难以实现，因为该结构中不同对象处于嵌套
聚合的多个不同层次，因此一个外部迭代器为跟踪对象必须存储一条纵贯该composite的路径。
8>空迭代器：
一个空迭代器是一个退化的迭代器，它可以帮助处理边界条件，也就是stl中的end()。
｀ 10:代码示例： */
//Aggregate：定义了一些接口
template<class Item>
class List
{
public:
List(long size= DEFAULT_LIST_CAPACITY);
long Count() const;
Item& Get(long index) const;
};
//abstract Iterator:定义迭代器的接口
template<class Item>
class Iterator
{
public:
virtual void First() = 0;
virtual void Next() = 0;
virtual bool IsDone() const = 0;
virtual Item CurrenItem() const = 0;
protected:
Iterator();
};
//ConcreteIterator：
template<class Item>
class ListIterator : public Iterator<Item>
{
public:
ListIterator(const List<Item>* aList);
virtual void First();
virtual void Next();
virtual bool IsDone() const;
virtual Item CurrenItem() const;
private:
const List<Item>* _list;
long _current;
}
//只要把当前的位置设置为0就是第一个
template<class Item>
void ListIterator<Item>::First()
{
_current = 0;
}
//下一个就是把位置加一
template<class Item>
void ListIterator<Item>::Next()
{
_current++;
}
//如果完成了，说明当前位置大于等于list中的元素了
template<class Item>
bool ListIterator<Item>::IsDone() const
{
return _current >= _list->Count();
}
//只要当前的位置小于元素数量，就返回当前元素。
template<class Item>
Item ListIterator<Item>::CurrenItem() const
{
if(IsDone())
throw IteratorOutofBounds;
return _list->Get(_current);
}
//这是一个客户自定义打印函数
void PrintEmployees(Iterator<Employee*>& i)
{
for(i.First(); !i.IsDone(); i.Next())
i.CurrenItem()->Print();
}
//定义一个指向指针list
List<Employee*>* employee;
//...
//定义迭代器
ListIterator<Employee*> forward(employee);
ReverseListIterator<Employee*> backward(employee);
PrintEmployees(forward);
PrintEmployees(backward);
//这是一个不同的list，但是客户需要记住不同的迭代器，会很麻烦，所以我们需要在list
//中实现一个工厂方法，它能直接返回一个abstract类型的迭代器。
SkipList<Employee*>* employees;
//...
SkipListIterator<Employee*> Iterator(employees);
PrintEmployees(iterator);
//抽象的list
template<class Item>
class AbstractList
{
public:
virtual Iterator<Item>* CreateIterator() const = 0;
};
template<class Item>
Iterator<Item>* List<Item>::CreateIterator() const
{
return new ListIterator<Item>(this);
}
//这样可以不使用具体迭代器类型，直接使用list对象的create函数来创造一个迭代器。
AbstractList<Employee*>* employee;
Iterator<Employee*>* iterator = employee->CreateIterator();
PrintEmployees(*iterator);
delete iterator;
//为了保证迭代器被删除，可以使用智能指针
template<class Item>
class IteratorPtr
{
public:
IteratorPtr(Iterator<Item>* i): _i(i){}
_IteratorPtr(){delete _i};
//每个智能指针都要实现的两个重载
Iterator<Item>* operator->() { return _i;}
Iterator<Item>* operator*() { return *_i;}
private:
IteratorPtr(const IteratorPtr&);
IteratorPtr& operator=(const IteratorPtr&);
private:
Iterator<Item>* _i;
};
//这样就不需要delete了。
AbstractList<Employee*>* employee;
IteratorPtr<Employee*>* iterator = employee->CreateIterator();
PrintEmployees(*iterator);
//一个内部的ListIterator： 遍历操作在内部实现
template<class Item>
class ListTraverser
{
public:
ListTraverser(List<Item>* aList);
bool Traverse();
protected:
virtual bool ProcessItem(const Item&) = 0;
private:
ListIterator<Item> _iterator;
};
template<class Item>
ListTraverser<Item>::ListTraverser(List<Item>* aList)
:_iterator(aList){}
//遍历操作
template<class Item>
bool ListTraverser<Item>::Traverse()
{
bool result = false;
for(_iterator.First(); !_iterator.IsDone(); _iterator.Next())
{
result = ProcessItem(_iterator.CurrenItem());
if(result == false)
break;
}
return result;
}
//如果需要打印不同的链表，必须实现不同的迭代器，所以内部迭代器实现会比较麻烦。
class PrintNEmployees : public ListTraverser<Employee*>
{
public:
PrintNEmployees(List<Employee*>* aList, int n)
: ListTraverser<Employee*>(aList), _total(n), _count(0){}
protected:
bool ProcessItem(Employee* const&);
private:
int _total;
int _count;
}
bool PrintNEmployees::ProcessItem(Employee* const& e)
{
_count++;
e->Print();
return _count < _total;
}
//这里就不需要自己实现遍历函数，直接调用内部迭代器的函数打印。
List<Employee*>* employees;
PrintNEmployees pa(employees, 10);
pa.Traverse();
ListIterator<Employee*> i(employees);
//下面是外部迭代器的打印过程，必须自己实现逻辑
int count = 0;
for(i.First(); !i.IsDone(); i.Next())
{
count++;
i.CurrenItem()->Print();
if(count >= 10)
{
break;
}
}
//这个迭代器可以过滤一些元素，只有通过测试菜能打印出来
template<class Item>
class FilteringListTraverser
{
public:
FilteringListTraverser(List<Item>* aList);
bool Traverse();
protected:
virtual bool ProcessItem(const Item&) = 0;
virtual bool TestItem(const Item&) = 0;
private:
ListIterator<Item> _iterator;
};
template<class Item>
void FilteringListTraverser<Item>::Traverse()
{
bool result = false;
for(_iterator.First(); !=_iterator.IsDone(); _iterator.Next())
{
//先测试
if(TestItem(_iterator.CurrenItem()))
{
result = ProcessItem(_iterator.CurrenItem());
if(result == false)
break;
}
}
return result;
}