zoukankan      html  css  js  c++  java
  • 迭代器模式

    迭代器模式,提供一种方法顺序訪问一个聚合对象中各个元素,而又不暴露该对象的内部表示。
    迭代器模式为遍历不同的聚集结构提供如開始、下一个、是否结束、当前哪一项等统一的接口。

    应用场景:
    1. 当你须要訪问一个聚集对象。并且无论这些对象是什么都要遍历一遍的时候,你就应该考虑使用迭代器模式。

    2. 当你须要对聚集对象有多种遍历时。能够考虑使用迭代器模式。
    长处:
    迭代器模式就是分离了集合对象的遍历行为,抽象出一个迭代器类来负责,这样既能够做到不暴露集合内部结构。又可让外部代码透明的訪问集合内部的数据。

    #include "stdafx.h"
    #include <iostream>
    #include <vector>
    using namespace std;
    
    template<typename T >
    class Iterator
    {
    public:
            virtual ~Iterator(){};
            virtual void First() = 0;
            virtual void Next() = 0;
            virtual bool IsDone() const = 0;
            virtual  T* CurrentItem() = 0;
    };
    
    template<typename T >
    class ConcreteAggregate ;
    
    template<typename T >
    class Aggregate
    {
    public:
            virtual ~Aggregate() {};
            virtual Iterator< T>* CreateIterator() = 0;
    };
    
    template<typename T >
    class ConcreteIterator :public Iterator <T >
    {
    private:
            ConcreteAggregate<T >* m_pAggre;
            int current = 0;
    public:
            virtual ~ConcreteIterator()
           {
                   delete m_pAggre;
           }
           ConcreteIterator( ConcreteAggregate<T >* pAggre ) :m_pAggre(pAggre), current(0)
           {}
    
            virtual void First()
           {
                  current = 0;
           }
    
            virtual void Next()
           {
                   if (current < m_pAggre->GetLen())
                         ++current;
           }
    
            virtual bool IsDone() const
           {
                   return (current >= m_pAggre->GetLen());
           }
    
            virtual T* CurrentItem()
           {
                   if (current <= m_pAggre->GetLen())
                          return &(*m_pAggre)[current];
                   else
                          return NULL;
           }
    
    };
    
    template<typename T >
    class ConcreteAggregate :public Aggregate <T >
    {
    private:
            vector< T> m_Data;
    public:
           ConcreteAggregate()
           {
                  m_Data.push_back(1);
                  m_Data.push_back(2);
                  m_Data.push_back(3);
           }
    
            virtual Iterator< T>* CreateIterator()
           {
                   return new ConcreteIterator<T >(this );
           }
    
            T& operator[]( int index)
           {
                   return m_Data[ index];
           }
    
            int GetLen()
           {
                   return m_Data.size();
           }
    };
    

    // IteratorPattern.cpp : Defines the entry point for the console application.
    //
    
    #include "stdafx.h"
    #include "Iterator.h"
    #include <iostream>
    
    int _tmain (int argc , _TCHAR * argv [])
    {
            Aggregate< int>* pAgg = new ConcreteAggregate<int >();
            Iterator< int>* it = pAgg->CreateIterator();
            for (it->First(); !it->IsDone(); it->Next())
           {
                  std::cout <<*( it->CurrentItem() )<< std::endl;
           }
    
           getchar();
            return 0;
    }
    


  • 相关阅读:
    你是一直认为 count(1) 比 count(*) 效率高么?
    php 判断是不是https链接
    php 版本比较
    php 执行效率
    redis 队列缓存 + mysql 批量入库 + php 离线整合
    php 高并发下数据同步的问题
    一个合格的工程师的知识结构
    php 代码编写的格式
    php 四种基础算法 ---- 快速排序法
    php 四种基础算法 ---- 插入排序法
  • 原文地址:https://www.cnblogs.com/yxwkf/p/5287223.html
Copyright © 2011-2022 走看看