std::istream_iterator y std::ostream_iterator en C++ STL

STL es una biblioteca muy poderosa en C++. Está fuertemente construido sobre los principios de la programación de plantillas. 
La biblioteca STL tiene tres componentes principales: 

1. Contenedores: estas clases definen las estructuras de datos que se utilizan para contener los datos. Los datos pueden almacenarse en listas enlazadas, árboles o arrays. Los contenedores proporcionados en STL son vector, dequeue, list, forward list, set, multiset, map y multimap.
2. Algoritmos: La librería STL también nos proporciona funciones para procesar los datos almacenados en contenedores. Estas funciones se proporcionan en el archivo de encabezado del algoritmo .
3. Iteradores: Los iteradores son el enlace entre los Contenedores y los Algoritmos. Son la interfaz común para estas clases. Un iterador es un objeto que se puede utilizar para iterar sobre los elementos de un contenedor. Por lo tanto, los algoritmos utilizan iteradores para modificar los contenedores. 
    

Los tres componentes están diseñados de tal manera que confirman los principios de abstracción de datos. Por lo tanto, cualquier objeto que contenga datos y se comporte como un contenedor , es un contenedor. De manera similar, cualquier iterador que barre los elementos de un contenedor es un iterador.
Si se puede usar un iterador para acceder a los elementos de un contenedor de datos, ¿qué pasa con los flujos? De acuerdo con el diseño, los flujos también son contenedores de datos, por lo que C++ nos proporciona iteradores para iterar sobre los elementos presentes en cualquier flujo. Estos iteradores se denominan iteradores de flujo . Para usar estos iteradores , se debe incluir el archivo de encabezado  del iterador .
Los iteradores de flujo son iteradores de flujo de entrada o iteradores de flujo de salida. Las clases para estos iteradores sonistream_iterator y ostream_iterator. Estos iteradores se comportan como iteradores de entrada e iteradores de salida respectivamente . 
 

iterador_istream

Definición de clase para istream_iterator 

namespace std {
    template < typename T, typename charT=char, 
               typename traits=char_traits <charT> >
    class istream_iterator;
}

Sintaxis: 

istream_iterator<T>(stream)
T:      Template parameter for specifying type of data
stream: The object representing the stream

ostream_iterator<T>(stream, delim).
stream: The object representing the stream.
T:      Template Parameter for data type in the stream
delim:  An optional char sequence that is used to 
        separate the data items while displaying them.

Nota :  

• Usando un iterador solo podemos acceder a elementos de un solo tipo.
• istream_iterator tiene un iterador de fin de flujo de estado especial que se adquiere cuando se alcanza el final del flujo o cuando falla una operación de entrada. El constructor predeterminado devuelve el final del iterador de flujo.

iterador_ostream

Definición de clase para ostream_iterator  

namespace std {
    template < typename T, typename charT=char, 
               typename traits=char_traits <charT> >
    class ostream_iterator;
}

Sintaxis:  

OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);

first: Input Iterator to the first element 
in source from where elements need to be copied.
last:  Input Iterator to the last element 
in source till where elements need to be copied.
result: Output iterator to the first element 
in the destination container to where elements will copied.

Return Value: Iterator pointing to the last element that was copied to the destination.

Los argumentos de la segunda y tercera plantilla tienen valores predeterminados asignados. Solo necesitamos especificar el primer parámetro de plantilla que especifica el tipo de datos presentes en el flujo, es decir, si el flujo contiene números enteros, flotantes o strings. 
Ejemplos:  

istream_iterator cin_it(cin) is an iterator for the stream cin.
ostream_iterator cout_it(cout, " ") is an iterator for the stream cout.
ostream_iterator cout_it(cout) is an iterator for stream cout, with no delimiter.

 Importancia de los iteradores de flujo
La ventaja de los iteradores de flujo es que proporcionan una interfaz común para acceder a elementos en el flujo de E/S, flujos de archivos y también otros flujos a dispositivos físicos externos. 

• Una vez que se ha obtenido un iterador para el flujo respectivo, el código que sigue es casi el mismo para todos los tipos de flujos.
• Por lo tanto, tareas como leer desde un flujo de entrada y leer desde otro flujo externo se vuelven similares.
• Los iteradores de flujo nos permiten acceder a todos los poderosos algoritmos STL como for_each, replace_if, que toman un rango de entrada para operar. Una función particularmente útil es la función copy() . Esta función se utiliza para copiar los elementos de un contenedor a otro.
• Usando la función copy(), podemos transferir fácilmente datos de un flujo a un contenedor y viceversa. Aquí hay algunos programas de ejemplo para demostrar cómo trabajar con iteradores de flujo.

Ejemplo 1 

// Cpp program to illustrate
// Read a bunch of integers from the input stream
// and print them to output stream
 
#include <algorithm>
#include <iostream>
#include <iterator>
 
using namespace std;
int main()
{
 
    // Get input stream and end of stream iterators
    istream_iterator<int> cin_it(cin);
    istream_iterator<int> eos;
 
    // Get output stream iterators
    ostream_iterator<int> cout_it(cout, " ");
 
    // We have both input and output iterators, now we can treat them
    // as containers. Using copy function we transfer data from one
    // container to another.
    // Copy elements from input to output using copy function
    copy(cin_it, eos, cout_it);
 
    return 0;
}

Input: 1 2 3 4 5 
Output: 1 2 3 4 5

Ejemplo 2 

// Cpp program to illustrate
// Read a bunch of strings from a file
// sort them lexicographically and print them to output stream
 
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
 
using namespace std;
int main()
{
 
    // Define a vector to store the strings received from input
    vector<string> strings_v;
 
    // Define the filestream object used to read data from file
    ifstream fin("input_file.txt");
 
    // Get input stream and end of stream iterators
    istream_iterator<string> fin_it(fin);
    istream_iterator<string> eos;
 
    // Get output stream iterators
    ostream_iterator<string> cout_it(cout, " ");
 
    // Copy elements from input to vector using copy function
    copy(fin_it, eos, back_inserter(strings_v));
 
    // Sort the vector
    sort(strings_v.begin(), strings_v.end());
 
    // Copy elements from vector to output
    copy(strings_v.begin(), strings_v.end(), cout_it);
 
    return 0;
}

Contents of File "input_file.txt": quick brown fox jumps over the lazy dog
Output: brown dog fox jumps lazy over quick the 

Ejemplo 3: 

// Cpp program to illustrate
 
// Read a bunch of integers from the stream
// print the sorted order of even integers only
 
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
 
using namespace std;
int main()
{
 
    // Define a vector to store the even integers received from input
    vector<int> vi;
 
    // Get input stream and end of stream iterators
    istream_iterator<int> cin_it(cin);
    istream_iterator<int> eos;
 
    // Get output stream iterators
    ostream_iterator<int> cout_it(cout, " ");
 
    // Copy even integer elements from input to vector using for_each function
    for_each(cin_it, eos, [&](int a) {
        if (a % 2 == 0) {
            // if a is even push it to vector
            vi.push_back(a);
        }
    });
 
    // Sort the vector
    sort(vi.begin(), vi.end());
 
    // Copy elements from vector to output
    copy(vi.begin(), vi.end(), cout_it);
 
    return 0;
}

Input: 1 4 3 2 6 8 31 52 
Output: 2 4 6 8 52 

Referencias:  
istream_iterator  
ostream_iterator