En este capítulo abordaremos el tema de la manipulación de datos a través de los dispositivos de entrada y salida estándar por medio de ciertos componentes lógicos conocidos como: streams. A manera de definición, un stream es una especie de canal a través del cual fluyen los datos. Técnicamente, un stream es el enlace lógico utilizado por el programador en C, C++ para leer o escribir datos desde y hacia los dispositivos estándar conectados a la PC. Normalmente, el dispositivo estándar para manipular entradas es el teclado y este, en C++, está asociado al objeto cin; el dispositivo estándar de salida está asociado (generalmente) con la pantalla o monitor de despliegue de la PC y, el mismo, en C++ se puede acceder por medio del objeto cout. El dispositivo estándar para mensajes de error es el cerr, y el mismo está asociado por defecto con la pantalla o monitor de despliegue. Otro dispositivo estándar es el impresor, pero este último no es soportado por los objetos de la iostream. Los programadores que hayan tenido alguna experiencia al programar en C estándar, notarán que los tres objetos mencionados coinciden con los dispositivos: stdin, stdout y stderr. La tabla que se muestra en seguida puede servirnos de base.

[editar] La iostream

La iostream es la la librería estándar en C++ para poder tener acceso a los dispositivos estándar de entrada y/o salida. En sus programas, si usted desea hacer uso de los objectos cin, cout, cerr y clog tendrá que incluir ( por medio de la directiva #include ) el uso de la librería iostream. En la iostream se encuentran definidas las clases ios ( misma que es la base para las clases que implementen operaciones de entrada y/o salida de datos ), istream ( para operaciones de entrada ) y ostream ( para operaciones de salida ). Aparte de las clases mencionadas, en la iostream se encuentra una lista de variables y constantes ( atributos ) que son accesibles por el usuario a travez del operador de ámbito ( :: ).

[editar] Streams automáticos

Si usted, usa la directiva #include <iostream.h> o #include <iostream> en sus programas, automáticamente la iostream pone a su disposición los objetos cin, cout, clog y cerr, de tal manera que usted puede comenzar a enviar o recibir información a travez de los mismos sin siquiera preocuparse de su creación. Asi, un sencillo ejemplo del uso de los objetos mecionados se muestra en seguida.

// De nuevo con el hola mundo...
#include <iostream.h>
int main()
{
    cout << "Hola mundo";    // imprimir mensaje (en la pantalla)
    cin.get();    // lectura ( entrada del teclado )
    return 0;
}

[editar] Operadores de direccionamiento

Los operadores de direccionamiento son los encargados de manipular el flujo de datos desde o hacia el dispositivo referenciado por un stream específico. El operador de direccionamiento para salidas es una pareja de simbolos de "menor que" <<, y el operador de direccionamiento para entradas es una pareja de simbolos de "mayor que" >>. Los operadores de direccionamiento se colocan entre dos operandos, el primero es el Stream y el segundo es una variable o constante que proporciona o recibe los datos de la operación. Por ejemplo, en el siguiente programa y en la instrucción cout << "Entre su nombre: "; la constante "Entre su nombre: " es la fuente o quien proporciona los datos para el objeto cout. Mientras que en la instrucción cin >> nombre la variable nombre es el destino o quien recibe los datos provenientes del objeto cin.

// De nuevo con el hola mundo...
#include <iostream.h>
int main()
{
    char nombre[80];
    cout << "Entre su nombre: ";
    cin  >> nombre;
    cout << "Hola," << nombre;
    cin.get();
    return 0;
}

Observe que si en una misma línea de comando se desea leer o escribir sobre varios campos a la vez, no es necesario nombrar más de una vez al stream. Ejemplos:

cout << "Hola," << nombre;
cin >> A >> B >> C;

[editar] Banderas de I/O

En esta sección abordaremos de manera más directa el tema sobre el control de formato para los stream de C++. Especificamente, veremos las tres diferentes formas que existen en C++ para manipular las banderas relacionadas a los stream y que nos permitirán gobernar de una manera más precisa la forma para representar datos de salida. En ese sentido, veremos que la primera de las forma que nos permitirá el formateo sera a travez de las funciones flags(), setf() y unsetf(), la segunda y la tercera forma las encontraremos en ciertos manipuladores directos definidos en las librerias <iostream> y <iomanip>.

[editar] Banderas de formato:

C++ define algunas banderas de formato para entradas y salidas estándar, las cuales pueden ser manipuladas a travez de la funciones (métodos) flags(), setf(), y unsetf(). Por ejemplo,

cout.setf(ios::left);

activa la justificación a la izquierda para todas las salidas dirigidas hacia cout.

A continuación se muestra una tabla de referencia de las banderas de I/O.

Manipulando la lista de banderas de I/O de C++ (mostrada arriva) se pueden controlar los aspectos relacionados a la forma con la cual se desean presentar los datos en la salida. Por ejemplo, el programa que se muestra en seguida, activa la bandera boolalpha para mostrar los resultados de operaciones booleanas como "true" o "false" en lugar de "0" o "1" como es lo normal.

// Programación con C++
// programa Banderas01.cpp;
// probado en Dev-Cpp Versión 4.9.9.2
 
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    cout << "0 > 1 ? " << '\t' << (0 > 1) << endl;
    cout << "5 > 1 ? " << '\t' << (5 > 1) << endl;
 
    cout.setf(ios::boolalpha); // activar bandera
    cout << "0 > 1 ? " << '\t' << (0 > 1) << endl;
    cout << "5 > 1 ? " << '\t' << (5 > 1) << endl;
 
    cin.get();
    return 0;
}

[editar] Manipuladores

La banderas también pueden manipularse directamente usando los siguientes manipuladores. Seguramente usted ya estará familiarizado con el manipulador endl, el mismo puede darle una idea de cómo son usados los manipuladores. Por ejemplo, usted puede establecer la bandera de números decimales usando el comando:

cout << dec;

La tabla que se muestra en seguida corresponde a los manipuladores definidos en <iostream>.

El programa que se muestra en seguida es un ejemplo de como emplear manipuladores directos para formatear salidas al stream estándar de salida ( cout ). En el mismo, se emplea el manipulador boolalpha para que los resultados de la operaciones logicas sean textuales, o sea, true o false y los manipuladores dec, hex y oct.

// Programación con C++
// programa Banderas02.cpp;
// probado en Dev-Cpp Versión 4.9.9.2
 
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
        cout << boolalpha;
        cout << "0 > 1 ? " << '\t' << (0 > 1) << endl;
        cout << "5 > 1 ? " << '\t' << (5 > 1) << endl;
 
        cout << dec << 2048 << endl;
        cout << hex << 2048 << endl;
        cout << oct << 2048 << dec << endl;
 
        cin.get();
        return 0;
}

Por último, y para terminar esta sección, hablaremos de los manipuladores definidos en la librería <iomanip>. Estos operan directamente igual que los que se vierón anteriormente, salvo que son parametrizados, es decir, operan en línea de salida mediante el operador <<, pero los mismos operan a manera de funciones, o sea con parámetros.

Atendiendo a las tablas de banderas, así como a las tablas de manipuladores para las mismas mostradas arriva, usted puede (con practica y perceverancia) lograr salidas con muy buena presentación hacia los dispositivos estándar. Por ejemplo, el programa que se mostrará a continuación muestra una de las formas de emplear manipuladores para formatear números de punto flotante, en el programa se despliega una lista de valores numéricos y se establece el campo de salida a una longitud de 12 caracteres y dos decimales.

// Programación con C++
// programa Banderas03.cpp;
// probado en Dev-Cpp Versión 4.9.9.2
 
#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
        double data[] = { 347.25, 45.75, 124.50, 456.80, 1500.90 };
        double total;
        int ancho = 12;
 
        cout.precision(2);
        cout.setf(ios::fixed);
 
        for (int c = 0; c < 5; c++)    {
                cout << setw(ancho) << data[c] << endl;
                total += data[c];
        }
        cout.fill('-');
        cout << setw(ancho) << "" << endl;
        cout.fill(' ');
        cout << setw(ancho) << total << endl;
 
        cout << "Por favor oprime Enter...";
        cin.get();
        return 0;
}

[editar] Streams para archivos o ficheros

Por definición, un archivo es una colección de datos almacenados en algún lugar. En C++, el programador puede considerar que un archivo es un stream, de tal manera que los objetos vistos en la sección anterior ( cin, cout, cerr y clog ) son una especie de archivo manipulados por streams. Este punto es de suma importancia, ya que todo lo que se ha mencionado acerca de los atributos, banderas y manipuladores; que son miembros de los objetos ( stream ) para entrada y salida estándar, son aplicables a los streams que usemos para trabajar con archivos en disco y/o cualquier otro dispositivo de almacenamiento. Hasta este momento, solamente se ha mencionado que los streams poseen banderas y que las mismas pueden alterarse a travez de los manipuladores, sin embargo, hace falta hablar acerca de los métodos o funciones que son miembros de dichos streams. Así, antes de ver un ejemplo para mostrar el uso de archivos en disco listaremos una tabla más, o sea, la de los métodos aplicables a los streams.

[editar] Abrir y cerrar archivo

A diferencia de los streams para dispositivos estándar, los cuales se creados y abiertos de manera automática, para trabajar con archivos en discos se debe primeramente "abrir el archivo", y luego de haber terminado de leer o escribir datos en el mismo, se debe "cerrar el archivo". En C++, en orden de trabajar con archivos en disco, podemos emplear las clases fstream, ifstream, y ofstream. Si usted desea abrir un archivo específico en modo de lectura y escritura use un objeto de la clase fstream, por el contrario, si desea abrir un archivo solo para lectura o solo para escritura use objetos de la clase ifstream y ofstream, respectivamente.

La sintaxis para crear objetos de las tres clase mencionadas es:

'''streams para lectura y escritura'''
fstream();
fstream(const char*, int, int = filebuf::openprot);
fstream(int);
fstream(int _f, char*, int);
 
'''streams solo para lectura'''
ifstream();
ifstream(const char*, int, int = filebuf::openprot);
ifstream(int);
ifstream(int _f, char*, int);
 
 
'''streams solo para escritura'''
ofstream();
ofstream(const char*, int, int = filebuf::openprot);
ofstream(int);
ofstream(int _f, char*, int);

Observe que la sintaxis para crear objetos de las tres clases mostradas arriva es la misma. Es decir,

1. El primer método constructor crea un objeto que no está (aún) asociado a un archivo en disco, en estos casos, se tendrá que usar el método stream.open("nombre de archivo"); para establecer la conección entre el stream y el archivo en disco.
2. El segundo método constructor crea un objeto asociado a un archivo en disco, en estos casos, el archivo en el disco queda abierto y asociado al stream. En este, el parámetro char * apunta a una cadena de caracteres con el nombre del archivo.
3. El tecer método crea un stream a raiz de un identificador de archivo.
4. El cuarto método crea un stream a raiz de un identificador de archivo, un buffer y tamaño de buffer específicos.

Para nuestro primer ejemplo usaremos el segundo de los constructores mencionados. Así, el programa que se muestra en seguida realiza las siguientes tareas:

1. Crea y escribe sobre el archivo de texto test.$$$
2. Abre y lee los datos del archivo test.$$
3. Cierra el archivo test.$$

Para el caso que se presenta se debe prestar atención a los metodos:

1. bad(), para verificar el estado de error del stream
2. get(), para leer caracteres del stream
3. put(), para escribir caracteres en el stream
4. close(), para cerrar el archivo.

// Ejemplo de ifstream y ofstream
// En este programa se demuestra la forma de crear un archivo
// en disco por medio de objeto ofstream, y la manera abrir y
// leer un archivo por medio de un objeto ifstream.
 
#include <iostream.h>
#include <fstream.h>
#include <string.h>
 
char *filename = "test.$$$";
char *data     = "Esta línea de texto se guardará en el archivo test.$$$";
 
// crear un archivo en disco cuyo nombre es dado por filename
int crearArchivo(char *filename)
{
    ofstream fichero(filename); // crear o rescribir archivo
 
    // verificar la creación del archivo
    if ( fichero.bad() ) {
        cout << "Error al tratar de abrir archivo";
        cin.get();
        return 0;
    }
 
    // escribir datos al archivo
    for (int t = 0; t < strlen(data); t++ )
        fichero.put(data[t] );
 
    fichero.close();
    cout << "archivo creado exitosamente" << endl;
    return 0;
}
 
// abrir un archivo en disco cuyo nombre es dado por filename
int leerArchivo(char *filename)
{
    ifstream fichero(filename); // abrir archivo para lectura
 
    // verificar la apertura del archivo
    if ( fichero.bad() ) {
        cout << "Error al tratar de abrir archivo";
        cin.get();
        return 1;
    }
 
    // lectura de datos
    while ( ! fichero.eof() ) cout << (char)fichero.get();
    fichero.close();
    cout << endl << "archivo leido exitosamente" << endl;
    return 0;
}
 
int main()
{
    crearArchivo(filename);
    leerArchivo(filename);
    cout << endl << "Presione <Enter>...";
    cin.get();
    return 0;
}

Usando operadores de redirección ( <<, >> )
sobre streams asociados con archivos en disco.

No hay que olvidar que si un archivo es asociado a un stream las operaciones de entrada y/o salida para dicho archivo se hacen a travez del stream y, por lo tanto, se puede usar, no solo los operadores de redirección, sino tambien todos los metodos, manipuladores y atributos que se ha mencionado hasta este momento. Así, el objetivo del siguiente programa es demostrar como hacer uso del operador << sobre un archivo asociado a un stream de salida, y del operador >> sobre un archivo asociado a un stream de entrada. El ejemplo que se mostrará no es realmente útil, sin embargo cumple con su cometido, es decir, el punto de interes del mismo está en las líneas de código:

while ( ! fin.eof() ) {
    fin  >> temp;
    fout << temp ;
}

Encargadas de leer datos del archivo de entrada y de escribir los mismos en el archivo de salida.

#include <iostream.h>
#include <fstream.h>
 
char *filename = "test.$$$";
 
// abre y lee datos de un archivo en disco cuyo nombre es dado por filename
int leerArchivo(char *filename)
{
    ifstream fichero(filename); // abrir archivo para lectura
 
    // verificar la apertura del archivo
    if ( fichero.bad() ) {
        cout << "Error al tratar de abrir archivo";
        cin.get();
        return 1;
    }
 
    // lectura de datos
    while ( ! fichero.eof() ) cout << (char)fichero.get();
    fichero.close();
    cout << endl << "archivo leido exitosamente" << endl;
    return 0;
}
 
// crea una copia del archivo test.$$$ hacia test.bak
// Nota: ningun caracter de espaciado en el origen le es tranferido al destino
int backup(char *filename)
{
    char newname[80];
    int i = 0;
 
    // copia el nombre del archivo original y remplaza la extensión por "BAK".
    while (filename[i] != '.' ) newname[i] = filename[i++];
    newname[i] = '\0';
    strcat(newname, ".BAK");
 
    ifstream fin( filename );   // abrir archivo de entrada
    ofstream fout( newname, ios::trunc );  // abrir archivo de salida
 
    char temp;
    while ( ! fin.eof() ) {
      fin  >> temp;
      fout << temp ;
    }
 
    fin.close();
    fout.close();
    return 0;
}
 
int main()
{
    backup(filename);
    leerArchivo("test.bak");
    cout << endl << "Presione <Enter>...";
    cin.get();
    return 0;
}