Iteradores de entrada (Programación)

Iteradores de entrada (Programación) Concepto: Son de solo lectura y movimiento hacia delante, lo que significa que solo pueden usarse con algoritmos que no alteren los miembros del contenedor

Iteradores de entrada (Programación). (InputIterator) sirven a operaciones de lectura de datos. La fuente de datos puede ser un contenedor STL (lo más frecuente); un contenedor preconstruido en el lenguaje (matriz); un contenedor construido por el usuario (que satisfaga las condiciones requeridas), o un flujo de datos ("Stream").

Son de solo lectura y movimiento hacia delante, lo que significa que solo pueden usarse con algoritmos que no alteren los miembros del contenedor (son iteradores constantes), y solo está permitido con ellos el operador de desplazamiento hacia adelante ++. El operador de indirección *, y los relacionales igualdad == y desigualdad != siempre están disponibles entre iteradores de un mismo contenedor.

Se exige que los algoritmos que utilicen este tipo de iteradores sean de pasada simple. Esto significa que solo realizarán una pasada en cada elemento del contenedor sobre el que operan (no realizarán operaciones sobre ellos más que en una ocasión).

Condiciones

Cualquier tipoX simple o compuesto satisface las condiciones de un iterador de entrada para un tipo-valor T.

Descripción

template <class InputIterator, class T>
  InputIterator find (InputIterator first,
                      InputIterator last,
                      const T& value) {
     while (first != last && *first != value) ++first;
     return first;
}

Este algoritmo genérico es en realidad una función genérica (una plantilla). La función acepta tres argumentos; los dos primeros first y last, son iteradores de entrada (InputIterator) que delimitan el rango de la búsqueda. El tercer argumento value es una referencia a un valor constante del tipo T de los miembros del contenedor.

El bucle de la función se limita a incrementar el valor del primer iterador mientras no sea igual al segundo y el valor señalado sea distinto del buscado. Si se alcanza la concordancia el valor devuelto es el iterador en que se cumple la condición. Observe que si el valor buscado no se encuentra en el contenedor, el iterador devuelto es el límite superior del rango, de forma que si returned es el valor devuelto, la condición returned == last es señal de que no se ha encontrado el valor buscado. Si el rango de búsqueda se hubiera extendido a la totalidad del contenedor el iterador devuelto sería el valor past-the-end.

El algoritmo anterior pone de manifiesto tres características de los iteradores de entrada:

• Los operadores relacionales igualdad == y desigualdad != puede ser utilizado con dos iteradores de entrada. Lo mismo que ocurre con los punteros ordinarios, estos operadores solo puede utilizarse con iteradores correspondientes al mismo contenedor; la igualdad significa que ambos iteradores señalan al mismo elemento; la desigualdad es el caso contrario.
• Un iterador de entrada puede ser deferenciado mediante el operador de indirección *; el valor obtenido es el miembro del contenedor señalado por el iterador.
• Un iterador de entrada puede ser incrementado con el operador unario ++ para señalar al siguiente miembro de la secuencia.

El significado de los operadores desigualdad (!=), deferencia (*) y suma unaria (++) depende de como estén definidos en la clase operador de entrada (InputIterator) utilizada como primer argumento de la plantilla. Como es posible redefinir estas funciones-operador, la sobrecarga de iteradores también es posible, y como consecuencia final, el comportamiento de los algoritmos como el presente para ciertos tipos específicos.

Tipos de iteradores de entrada

Existen tres tipos principales de iteradores de entrada (InputIterator): punteros ordinarios; iteradores estándar de contenedor, e iteradores de flujo de entrada (Input stream iterator).

Punteros ordinarios

Las matrices ordinarias son un tipo de estructura de datos, y es fácil comprobar que los punteros a estas matrices satisfacen los criterios señalados para que puedan ser considerados como iteradores de entrada., y en consecuencia pueden aplicárseles los algoritmos de la STL. Por ejemplo, el siguiente código busca el valor 7 en una matriz de enteros de 100 elementos:

int data[100];
...
int* where = find(data, data+100, 7);

Una de las características de los iteradores de entrada es que no permiten operaciones de escritura sobre los datos del contenedor. En el caso de punteros a matrices regulares esto puede ser simulado fácilmente definiendo punteros-a-constantes.

Iteradores de contenedor estándar

La totalidad de los iteradores que pueden definirse para los contenedores de la STL pueden considerarse, al menos, como contenedores de entrada. Todos los contenedores de la STL (clases genéricas) que soportan iteradores, disponen de dos funciones-miembro begin() y end() que devuelven sendos iteradores al elemento inicial y después del último (past-the-end). Por ejemplo, suponiendo que tenemos un contenedor tipo list denominado aList previsto para manejar enteros, la forma de buscar un miembro de valor 7 sería:

list<int>::iterator where = find(aList.begin(), aList.end(), 7);

Esta expresión declara que where es un iterador a aList, y lo inicia con el valor devuelto por la función. La explicación de la declaración (Lvalue de la expresión) es que cada contenedor de la STL que soporta iteradores incluye en su declaración un tipo que es un iterador a la clase. Este tipo (que es en realidad una subclase genérica -plantilla- dentro del contenedor) tiene el nombre iterator (o cons_iterator si es constante. Esto permite que puedan declararse iteradores a estos contenedores utilizando una sintaxis uniforme como la utilizada en la sentencia anterior.

Iteradores de flujo de entrada

La STL también proporciona iteradores que pueden ser utilizados con los flujos de entrada. Son los denominados istream_iterator, que pueden ser utilizados con contenedores de la clase basic_istream.

Puede Consultar

• Función (programación)
• Operadores
• Sentencias (Programación)
• Iteradores (Programación)
• Iteradores de salida (Programación)
• Iteradores de inserción (Programación)

Fuente

• Iteradores
• Iteradores de entrada