Patrón iterador

^{[ 2 ]}

• Se debe acceder a los elementos de un objeto agregado y recorrerlos sin exponer su representación (estructuras de datos).
• Se deben definir nuevas operaciones de recorrido para un objeto agregado sin modificar su interfaz.

Definir las operaciones de acceso y recorrido en la interfaz del agregado es inflexible porque compromete al agregado a determinadas operaciones de acceso y recorrido, e imposibilita añadir nuevas operaciones posteriormente sin tener que modificar la interfaz del agregado.

• Defina un objeto separado (iterador) que encapsule el acceso y el recorrido de un objeto agregado.
• Los clientes utilizan un iterador para acceder y recorrer un agregado sin conocer su representación (estructuras de datos).

Se pueden usar diferentes iteradores para acceder a un agregado y recorrerlo de distintas maneras. Se pueden definir nuevas operaciones de acceso y recorrido de forma independiente mediante la definición de nuevos iteradores.

Véase también el diagrama de clases y secuencia UML a continuación.

En el diagrama de clases UML anterior , la clase se refiere (1) a la interfaz para crear un objeto ( ) y (2) a la interfaz para recorrer un objeto ( , ). La clase implementa la interfaz accediendo a la clase.ClientAggregateIteratorcreateIterator()IteratorAggregatenext()hasNext()Iterator1IteratorAggregate1

El diagrama de secuencia UML muestra las interacciones en tiempo de ejecución: El objeto llama a un objeto, que crea un objeto y lo devuelve al . El utiliza luego para recorrer los elementos del objeto.ClientcreateIterator()Aggregate1Iterator1ClientClientIterator1Aggregate1

C++ implementa iteradores con la semántica de punteros en ese lenguaje. En C++, una clase puede sobrecargar todas las operaciones de puntero, por lo que se puede implementar un iterador que actúe más o menos como un puntero, con desreferenciación, incremento y decremento. Esto tiene la ventaja de que los algoritmos de C++ como std::sortse pueden aplicar inmediatamente a búferes de memoria simples, y que no hay una nueva sintaxis que aprender. Sin embargo, requiere un iterador "final" para comprobar la igualdad, en lugar de permitir que un iterador sepa que ha llegado al final. En el lenguaje C++, decimos que un iterador modela el concepto de iterador .

Esta implementación en C++23 se basa en el capítulo "Generalizando el vector una vez más". ^{[ 5 ]}

importar std ;plantilla < typename T > usando InitializerList = std :: initializer_list < T > ; usando OutOfRangeException = std :: out_of_range ; plantilla < typename T > usando UniquePtr = std :: unique_ptr < T > ;clase DoubleVector { privado : UniquePtr < double [] > elementos ; tamaño_t listSize ; público : usando Iterador = double * ;[[ nodiscard ]] Iterador begin () const noexcept { return elements ; }[[ nodiscard ]] Iterador fin () const noexcept { return elements + listSize ; } DoubleVector ( InitializerList < double > list ) : elements { std :: make_unique < double [] > ( list . size ())}, listSize { list . size ()} { double * p = elements ; for ( auto i = list . begin (); i != list . end (); ++ i , ++ p ) { * p = * i ; } // alternativamente implementado con // std::ranges::copy(list, elements.get()) }~ DoubleVector () = valor predeterminado ;[[ nodiscard ]] size_t size () const noexcept { return listSize ; }[[ nodiscard ]] double & operator []( size_t n ) { if ( n >= listSize ) { throw OutOfRangeException ( "DoubleVector::operator[] fuera de rango!" ); } return elements [ n ]; }DoubleVector ( const DoubleVector & ) = delete ; // deshabilitar la construcción de copia DoubleVector & operator = ( const DoubleVector & ) = delete ; // deshabilitar la asignación de copia };int main ( int argc , char * argv []) { DoubleVector v = { 1.1 * 1.1 , 2.2 * 2.2 }; for ( const double & x : v ) { std :: println ( " {}" , x ); } for ( size_t i = v.begin ( ); i ! = v.end (); ++ i ) { std :: println ( "{}" , * i ); } for ( size_t i = 0 ; i <= v.size ( ) ; ++ i ) { std :: println ( " {}" , v [ i ] ); } }

La salida del programa es

1.21 4.84 1.21 4.84 1.21 4.84 terminate called after throwing an instance of ' OutOfRangeException ' what () : DoubleVector :: operator [] out of range !