设计模式 笔记 迭代器模式 Iterator

//---------------------------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() =
;

virtual void Next() =
;

virtual bool IsDone()
;

virtual Item CurrenItem()
const = ;

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 =
;

}

//下一个就是把位置加一

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 = ;

};

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&) =
;

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(){}

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,
);

pa.Traverse();

ListIterator<Employee*> i(employees);

//下面是外部迭代器的打印过程，必须自己实现逻辑

int count =
;

for(i.First(); !i.IsDone(); i.Next())

{

count++;

i.CurrenItem()->Print();

)

{

break;

}

}

//这个迭代器可以过滤一些元素，只有通过测试菜能打印出来

template<class Item>

class FilteringListTraverser

{

public:

FilteringListTraverser(List<Item>* aList);

bool Traverse();

protected:

virtual bool ProcessItem(const Item&) =
;

virtual bool TestItem(const Item&) =
;

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;

}