Iterator 迭代器

意图

提供一种方法顺序访问一个聚合对象中各个元素 , 而又不需暴露该对象的内部表示。

动机

一个聚合对象, 如列表(list), 应该提供一种方法来让别人可以访问它的元素，而又不需暴露它的内部结构

迭代器类定义了一个访问该列表元素的接口。迭代器对象负责跟踪当前的元素 ；即, 它知道哪些元素已经遍历过了。

适用性

• 访问一个聚合对象的内容而无需暴露它的内部表示。
• 支持对聚合对象的多种遍历。
• 为遍历不同的聚合结构提供一个统一的接口 (即, 支持多态迭代)。

结构

定义一个抽象列表类AbstractList，它提供操作列表的公共接口。类似地，我们也需要一个抽象的迭代器类Iterator，它定义公共的迭代接口。然后我们可以为每个不同的列表实现定义具体的Iterator子类。这样迭代机制就与具体的聚合类无关了。

参与者

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

ConcreteIterator：具体迭代器实现迭代器接口;对该聚合遍历时跟踪当前位置。

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

ConcreteAggregate：具体聚合实现创建相应迭代器的接口，该操作返回ConcreteAggregate的一个适当的实例。

效果

• 访问一个聚合对象的内容而无需暴露它的内部表示；
• 支持对聚合对象的多种遍历（从前到后，从后到前）；
• 为遍历不同的聚合结构提供一个统一的接口，即支持多态迭代。

实现

 #include <iostream>
 using namespace std;

 typedef struct tagNode
 {
     int value;
     tagNode *pNext;
 }Node;

 class JTList
 {
 public:
     JTList() : m_pHead(NULL), m_pTail(NULL){};
     JTList(const JTList &);
     ~JTList();
     JTList &operator=(const JTList &);

     long GetCount() const;
     Node *Get(const long index) const;
     Node *First() const;
     Node *Last() const;
     bool Includes(const int &) const;

     void Append(const int &);
     void Remove(Node *pNode);
     void RemoveAll();

 private:
     Node *m_pHead;
     Node *m_pTail;
     long m_lCount;
 };

 class Iterator
 {
 public:
     virtual void First() = ;
     virtual void Next() = ;
     virtual bool IsDone() const = ;
     virtual Node *CurrentItem() const = ;
 };

 class JTListIterator : public Iterator
 {
 public:
     JTListIterator(JTList *pList) : m_pJTList(pList), m_pCurrent(NULL){}

     virtual void First();
     virtual void Next();
     virtual bool IsDone() const;
     virtual Node *CurrentItem() const;

 private:
     JTList *m_pJTList;
     Node *m_pCurrent;
 };

 JTList::~JTList()
 {
     Node *pCurrent = m_pHead;
     Node *pNextNode = NULL;
     while (pCurrent)
     {
         pNextNode = pCurrent->pNext;
         delete pCurrent;
         pCurrent = pNextNode;
     }
 }

 long JTList::GetCount()const
 {
     return m_lCount;
 }

 Node *JTList::Get(const long index) const
 {
     // The min index is 0, max index is count - 1
     if (index > m_lCount -  || index < )
     {
         return NULL;
     }

     int iPosTemp = ;
     Node *pNodeTemp = m_pHead;
     while (pNodeTemp)
     {
         if (index == iPosTemp++)
         {
             return pNodeTemp;
         }
         pNodeTemp = pNodeTemp->pNext;
     }
     return NULL;
 }

 Node *JTList::First() const
 {
     return m_pHead;
 }

 Node *JTList::Last() const
 {
     return m_pTail;
 }

 bool JTList::Includes(const int &value) const
 {
     Node *pNodeTemp = m_pHead;
     while (pNodeTemp)
     {
         if (value == pNodeTemp->value)
         {
             return true;
         }
         pNodeTemp = pNodeTemp->pNext;
     }
     return false;
 }

 void JTList::Append(const int &value)
 {
     // Create the new node
     Node *pInsertNode = new Node;
     pInsertNode->value = value;
     pInsertNode->pNext = NULL;

     // This list is empty
     if (m_pHead == NULL)
     {
         m_pHead = m_pTail = pInsertNode;
     }
     else
     {
         m_pTail->pNext = pInsertNode;
         m_pTail = pInsertNode;
     }
     ++m_lCount;
 }

 void JTList::Remove(Node *pNode)
 {
     if (pNode == NULL || m_pHead == NULL || m_pTail == NULL)
     {
         return;
     }

     if (pNode == m_pHead) // If the deleting node is head node
     {
         Node *pNewHead = m_pHead->pNext;
         m_pHead = pNewHead;
     }
     else
     {
         // To get the deleting node's previous node
         Node *pPreviousNode = NULL;
         Node *pCurrentNode = m_pHead;
         while (pCurrentNode)
         {
             pPreviousNode = pCurrentNode;
             pCurrentNode = pCurrentNode->pNext;
             if (pCurrentNode == pNode)
             {
                 break;
             }
         }

         // To get the deleting node's next node
         Node *pNextNode = pNode->pNext;

         // If pNextNode is NULL, it means the deleting node is the tail node, we should change the m_pTail pointer
         if (pNextNode == NULL)
         {
             m_pTail = pPreviousNode;
         }

         // Relink the list
         pPreviousNode->pNext = pNextNode;
     }

     // Delete the node
     delete pNode;
     pNode = NULL;
     --m_lCount;
 }

 void JTList::RemoveAll()
 {
     delete this;
 }

 void JTListIterator::First()
 {
     m_pCurrent = m_pJTList->First();
 }

 void JTListIterator::Next()
 {
     m_pCurrent = m_pCurrent->pNext;
 }

 bool JTListIterator::IsDone() const
 {
     return m_pCurrent == m_pJTList->Last()->pNext;
 }

 Node *JTListIterator::CurrentItem() const
 {
     return m_pCurrent;
 }

 int main()
 {
     JTList *pJTList = new JTList;
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();
     pJTList->Append();

     Iterator *pIterator = new JTListIterator(pJTList);

     // Print the list by JTListIterator
     for (pIterator->First(); !pIterator->IsDone(); pIterator->Next())
     {
         cout << pIterator->CurrentItem()->value << "->";
     }
     cout << "NULL" << endl;

     // Test for removing
     Node *pDeleteNode = NULL;
     for (pIterator->First(); !pIterator->IsDone(); pIterator->Next())
     {
         pDeleteNode = pIterator->CurrentItem();
         if (pDeleteNode->value == )
         {
             pJTList->Remove(pDeleteNode);
             break;
         }
     }

     // Print the list by JTListIterator
     for (pIterator->First(); !pIterator->IsDone(); pIterator->Next())
     {
         cout << pIterator->CurrentItem()->value << "->";
     }
     cout << "NULL" << endl;

     delete pIterator;
     delete pJTList;

     return ;
 }