迭代器模式
C++
# include <iostream>
# include <string>
# include <vector> using namespace std;
class Iterator
{
public : Iterator ( ) { } ; virtual ~ Iterator ( ) { } ; virtual string First ( ) = 0 ; virtual string Next ( ) = 0 ; virtual string CurrentItem ( ) = 0 ; virtual bool IsDone ( ) = 0 ;
} ;
class Aggregate
{
public : virtual int Count ( ) = 0 ; virtual void Push ( const string & strValue) = 0 ; virtual string Pop ( const int nIndex) = 0 ; virtual Iterator * CreateIterator ( ) = 0 ;
} ;
class ConcreteIterator : public Iterator
{
public : ConcreteIterator ( Aggregate * pAggregate) : m_nCurrent ( 0 ) , Iterator ( ) { m_Aggregate = pAggregate; } string First ( ) { return m_Aggregate-> Pop ( 0 ) ; } string Next ( ) { string strRet; m_nCurrent++ ; if ( m_nCurrent < m_Aggregate-> Count ( ) ) { strRet = m_Aggregate-> Pop ( m_nCurrent) ; } return strRet; } string CurrentItem ( ) { return m_Aggregate-> Pop ( m_nCurrent) ; } bool IsDone ( ) { return ( ( m_nCurrent >= m_Aggregate-> Count ( ) ) ? true : false ) ; } private : Aggregate * m_Aggregate; int m_nCurrent;
} ;
class ConcreteAggregate : public Aggregate
{
public : ConcreteAggregate ( ) : m_pIterator ( NULL ) { m_vecItems. clear ( ) ; } ~ ConcreteAggregate ( ) { if ( NULL != m_pIterator) { delete m_pIterator; m_pIterator = NULL ; } } Iterator * CreateIterator ( ) { if ( NULL == m_pIterator) { m_pIterator = new ConcreteIterator ( this ) ; } return m_pIterator; } int Count ( ) { return m_vecItems. size ( ) ; } void Push ( const string & strValue) { m_vecItems. push_back ( strValue) ; } string Pop ( const int nIndex) { string strRet; if ( nIndex < Count ( ) ) { strRet = m_vecItems[ nIndex] ; } return strRet; } private : vector< string> m_vecItems; Iterator * m_pIterator;
} ;
int main ( )
{ ConcreteAggregate * pName = NULL ; pName = new ConcreteAggregate ( ) ; if ( NULL != pName) { pName-> Push ( "hello" ) ; pName-> Push ( "word" ) ; pName-> Push ( "cxue" ) ; } Iterator * iter = NULL ; iter = pName-> CreateIterator ( ) ; if ( NULL != iter) { string strItem = iter-> First ( ) ; while ( ! iter-> IsDone ( ) ) { cout << iter-> CurrentItem ( ) << " is ok" << endl; iter-> Next ( ) ; } } return 0 ;
}
C
# include <stdio.h>
# include <stdlib.h>
# include <string.h> typedef struct _Iterator
{ struct _Aggregate * aggregate; int current;
} Iterator; typedef struct _Aggregate
{ int count; char * * items;
} Aggregate;
Iterator * Iterator_Create ( Aggregate * agg)
{ Iterator * it = ( Iterator * ) malloc ( sizeof ( Iterator) ) ; it-> aggregate = agg; it-> current = 0 ; return it;
}
void Iterator_Destroy ( Iterator * it)
{ free ( it) ;
}
char * Iterator_First ( Iterator * it)
{ if ( it && it-> aggregate && it-> aggregate-> count > 0 ) { return it-> aggregate-> items[ 0 ] ; } return NULL ;
}
char * Iterator_Next ( Iterator * it)
{ if ( it && it-> aggregate && it-> current >= 0 && it-> current < it-> aggregate-> count) { it-> current++ ; return it-> aggregate-> items[ it-> current] ; } return NULL ;
}
char * Iterator_CurrentItem ( Iterator * it)
{ if ( it && it-> aggregate && it-> current < it-> aggregate-> count) { return it-> aggregate-> items[ it-> current] ; } return NULL ;
}
int Iterator_IsDone ( Iterator * it)
{ return it-> current >= it-> aggregate-> count;
}
Aggregate * Aggregate_Create ( )
{ Aggregate * agg = ( Aggregate * ) malloc ( sizeof ( Aggregate) ) ; agg-> count = 0 ; agg-> items = NULL ; return agg;
}
void Aggregate_Destroy ( Aggregate * agg)
{ if ( agg-> items) { int i; for ( i = 0 ; i < agg-> count; i++ ) { free ( agg-> items[ i] ) ; } free ( agg-> items) ; } free ( agg) ;
}
void Aggregate_Add ( Aggregate * agg, const char * item)
{ if ( agg) { agg-> items = realloc ( agg-> items, sizeof ( char * ) * ( ++ agg-> count) ) ; agg-> items[ agg-> count - 1 ] = strdup ( item) ; }
} int main ( )
{ Aggregate * pName = Aggregate_Create ( ) ; Aggregate_Add ( pName, "hello" ) ; Aggregate_Add ( pName, "world" ) ; Aggregate_Add ( pName, "cxue" ) ; Iterator * iter = Iterator_Create ( pName) ; char * strItem = Iterator_First ( iter) ; while ( ! Iterator_IsDone ( iter) ) { printf ( "%s is ok\n" , Iterator_CurrentItem ( iter) ) ; strItem = Iterator_Next ( iter) ; } Iterator_Destroy ( iter) ; Aggregate_Destroy ( pName) ; return 0 ;
}