Programación en C++/Streams

De Wikilibros, la colección de libros de texto de contenido libre.
Saltar a: navegación, buscar
Funciones Arrays y cadenas de texto

Streams, entrada y salida de datos[editar]

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 la impresora, 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.


Tabla I/O : 01, dispositivos estándar de I/O
C estandar C++
stdin cin
stdout cout
stderr cerr
--- clog

La iostream[editar]

La iostream es la biblioteca 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 objetos cin, cout, cerr y clog tendrá que incluir ( por medio de la directiva #include ) el uso de la biblioteca 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 través del operador de ámbito ( :: ).

Streams automáticos[editar]

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 en el ámbito estándar (std), de tal manera que usted puede comenzar a enviar o recibir información a través de los mismos sin siquiera preocuparse de su creación. Asi, un sencillo ejemplo del uso de los objetos mencionados se muestra en seguida.

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

Operadores de direccionamiento[editar]

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 símbolos de "menor que" <<, y el operador de direccionamiento para entradas es una pareja de símbolos 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;

Banderas de I/O[editar]

En esta sección abordaremos de manera más directa el tema sobre el control de formato para los stream de C++. Específicamente, 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 través de las funciones flags(), setf() y unsetf(), la segunda y la tercera forma las encontraremos en ciertos manipuladores directos definidos en las bibliotecas <iostream> y <iomanip>.

Banderas de formato:[editar]

C++ define algunas banderas de formato para entradas y salidas estándar, las cuales pueden ser manipuladas a través 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.

Tabla I/O : 02, banderas de formato
Bandera Descripción
boolalpha Los valores booleanos pueden ser leídos/escritos usando las palabras "true" y "false"
dec Los valores numéricos se muestran en formato decimal
fixed Números de punto flotante se despliegan en forma normal
hex Los valores numéricos se muestran en formato hexadecimal
left La salida es justificada por la izquierda
oct Los valores numéricos se muestran en formato octal
right La salida es justificada por la derecha
scientific Números de punto flotante se despliegan en notación científica
showbase Despliega la base de todos los valores numéricos
showpoint Despliega el punto decimal y extra ceros, aún cuando no sean

necesarios

showpos Despliega el símbolo de más antes de valores positivos
skipws Descarta caracteres de espaciado (espacios, tabuladores, nuevas líneas) cuando se lee desde un stream
unitbuf Descarga el buffer después de cualquier inserción
uppercase Despliega la "e" en notaciones científicas y la "x" en notaciones decimales como letras mayúsculas


Manipulando la lista de banderas de I/O de C++ (mostrada arriba) 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 <<"\n0 > 1 ? "<<"\t"<<(0>1)<< endl;
    cout <<"\t5 > 1 ? "<<"\t"<<(5>1)<< endl;
 
    cout.setf(ios::boolalpha); // activar bandera
    cout <<"\n0 > 1 ? "<<"\t"<<(0>1)<< endl;
    cout <<"\t5 > 1 ? "<<"\t"<<(5>1)<< endl;
 
    cin.get();
    return 0;
}

Manipuladores[editar]

Las 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>.


Tabla I/O : 03, manipuladores en <iostream>
Manipulador Descripción Entrada Salida
bollalpha Activa la bandera boolalpha X X
dec Activa la bandera dec-imal X X
endl Escribe carácter de cambio de línea --- X
ends Escribe el carácter null --- X
fixed Activa la bandera fixed (para números reales) --- X
flush Descargar el stream --- X
hex Activa la bandera hex-adecimal X X
internal Activa la bandera interna --- X
left Activa la bandera left (izquierda) --- X
nobollalpha Desactiva la bandera boolalpha X X
noshowbase Desactiva la bandera showbase --- X
noshowpoint Desactiva la bandera showpoint --- X
noshowpos Desactiva la bandera showpos --- X
noskipws Desactiva la bandera skipws X ---
nounitbuf Desactiva la bandera unitbuf --- X
nouppercase Desactiva la bandera uppercase --- X
oct Activa la bandera oct-al X X
right Activa la bandera de justificar derecha --- X
scientific Activa la bandera scientific --- X
showbase Activa la bandera showbase --- X
showpoint Activa la bandera showpoint --- X
showpos Activa la bandera showpos --- X
skipws Activa la bandera skipws X ---
unitbuf Activa la bandera unitbuf --- X
uppercase Activa la bandera uppercase --- X
ws Limpiar cualquier espacio al inicio X ---


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 biblioteca <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.


Tabla I/O : 04, manipuladores en <iomanip>
Manipulador Descripción Entrada Salida
resetioflags( long f ) Desactiva las banderas especificadas por f X X
setbase( int base ) Establece la bases numérica a base --- X
setfill( int ch ) Establece carácter de relleno a ch --- X
setioflags( long f ) Activa las banderas especificadas por f X X
setprecision( int p ) Establece el número de digitos de precisión a p --- X
setw( int w ) Establece la longitud de campo a w --- X


Atendiendo a las tablas de banderas, así como a las tablas de manipuladores para las mismas mostradas arriba, 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;
}

Streams para archivos o ficheros[editar]

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 traves 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.


Tabla I/O : 05, métodos para objetos istream, ostream y fstream
Función Descripción
bad true si ha ocurrido un error
clear limpia las banderas de estado (status flags)
close cierra un stream
eof true si se alcanzó el fin de archivo
fail true si ha ocurrido un error
fill establecer manipulador de carácter de relleno
flags accesa o manipula las banderas de formato de un stream
flush vaciar el buffer de un stream
gcount número de caracteres leidos durante la última operación de entrada
get lectura de caracteres
getline lectura de una línea de caracteres
good true si no ha ocurrido un error
ignore leer y descartar caracteres
open abrir un stream de entrada y/o salida
peek verifica la siguiente entrada de carácter
precision manipula la precisión del stream
put escritura de caracteres
putback regresar caracteres al stream
rdstate regresa la bandera de estado de stream
read lee datos de un stream hacia un buffer
seekg realiza acceso aleatorio sobre un stream de entrada
seekp realiza acceso aleatorio sobre un stream de salida
setf cambiar las banderas de formato
tellg lee el puntero del stream de entrada
tellp lee el puntero del stream de salida
unsetf limpiar las banderas de formato
width accesa y manipula la longitud minima del campo
write escritura datos desde un buffer hacia un stream

Abrir y cerrar archivo[editar]

A diferencia de los streams para dispositivos estándar, los cuales son 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 arriba 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 conexió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>
#include <fstream>
#include <string.h>
 
 
using namespace std;
 
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 1;
    }
 
    // escribir datos al archivo
    for (unsigned 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 también 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: ningún carácter 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;
}


Funciones Arriba Arrays y cadenas de texto