Operaciones de escritura en archivos

Operaciones de escritura en archivos

El archivo de cabecera fstream.h define las clases ifstream, ostream y fstream para operaciones de lectura, escritura y lectura/escritura en archivos respectivamente. Para trabajar con archivos debemos crear objetos de éstas clases de acuerdo a las operaciones que deseamos efectuar. Empezamos con las operaciones de escritura, para lo cual básicamente declaramos un objeto de la clase ofstream, después utilizamos la función miembro open para abrir el archivo, escribimos en el archivo los datos que sean necesarios utilizando el operador de inserción y por último cerramos el archivo por medio de la función miembro close, éste proceso está ilustrado en nuestro primer programa, archiv01.cpp.

//*********************************************** // archiv01.cpp // Demuestra la escritura básica en archivo // ©1999, Jaime Virgilio Gómez Negrete //*********************************************** #include int main() { ofstream archivo; // objeto de la clase ofstream archivo.open("datos.txt"); archivo << "Primera línea de texto" <<>

En el programa se ha creado un objeto de la clase ofstream llamado archivo, posteriormente se utiliza la función miembro open para abrir el arcivo especificado en la cadena de texto que se encuentra dentro del paréntesis de la función. Por lo visto en el capítulo 3 sabemos que podemos invocar a la función constructora de clase de tal manera que el archivo también se puede abrir utilizando la siguiente instrucción:

ofstream archivo("datos.txt"); // constructora de ofstream

Naturalmente, al utilizar la función constructora ya no es necesario utilizar la función miembro open, ésta forma de abrir un archivo es preferida porque el código es más compacto y fácil de leer. De la misma forma que se utilizan manipuladores de salida para modificar la presentación en pantalla de los datos del programa, igual es posible utilizar éstos manipuladores al escribir datos en un archivo como lo demuestra el programa archiv02.cpp, observe que se utiliza un constructor para crear y abrir el archivo llamado Datos.txt:

//*********************************************** // archiv02.cpp // Demuestra el uso de manipuladores // ©1999, Jaime Virgilio Gómez Negrete //*********************************************** #include #include #include int main() { ofstream archivo("Datos.txt"); // constructor de ofstream int numero; cout << "Introduzca un numero:" <<>> numero; archivo << "El valor introducido en base 10 es: " <<>

Modos de apertura de archivo

Al especificar la apertura de un archivo como se ha mostrado en los programas anteriores, el programa sobreescribe cualquier archivo existente llamado Datos.txt en el directorio de trabajo del programa. Dependiendo del propósito del programa es posible que sea necesario agregar datos a los ya existentes en el archivo, o quizá sea necesario que las operaciones del programa no se lleven a cabo en caso de que el archivo especificado exista en el disco, para éstos casos podemos especificar el modo de apertura del archivo incluyendo un parámetro adicional en el constructor, cualquiera de los siguientes:

• ios::app Operaciones de añadidura.
• ios::ate Coloca el apuntador del archivo al final del mismo.
• ios::in Operaciones de lectura. Esta es la opción por defecto para objetos de la clase ifstream.
• ios::out Operaciones de escritura. Esta es la opción por defecto para objetos de la clase ofstream.
• ios::nocreate Si el archivo no existe se suspende la operación.
• ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operación se suspende.
• ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.
• ios::binary Operaciones binarias.

De esta manera, podemos modificar el modo de apertura del programa archiv02.cpp para que los datos del programa se concatenen en el archivo Datos.txt simplemente escribiendo el constructor así: ofstream archivo("Datos.txt", ios::app);. Si deseamos que el programa no sobreescriba un archivo existente especificamos el constructor de ésta manera: ofstream archivo("Datos.txt", ios::noreplace);. Utilizando los especificadores de modo de apertura se puede conseguir un mayor control en las operaciones de E/S en archivos.

Volver al principio

Operaciones de lectura de archivos

Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la clase ifstream y se procede prácticamente de la misma forma que lo expuesto en el apartado anterior. Después de abrir el archivo se puede leer su contenido utilizando las funciones miembro de la clase ifstream o bién el operador de extracción. Cuando se lee un archivo, por lo general se empieza al principio del mismo y se leerá su contenido hasta que se encuentre el final del archivo. Para determinar si se ha llegado al final del archivo se puede utilizar la función miembro eof como condición de un bucle while. Además se puede utilizar la función miembro fail para detectar un error al abrir el archivo, esto se demuestra en el siguiente programa, archiv03.cpp:

//*********************************************** // archiv03.cpp // Demuestra operaciones de lectura de archivos // ©1999, Jaime Virgilio Gómez Negrete //*********************************************** #include int main() { ifstream archivo("Besos.txt", ios::noreplace); char linea[128]; long contador = 0L; if(archivo.fail()) cerr << "Error al abrir el archivo Besos.txt" <<>

El programa crea un objeto de la clase ifstream para abrir el archivo llamado Besos.txt utilizando el constructor de clase y especificando la bandera ios::noreplace que evita que el archivo sea sobreescrito. Si por algún motivo ocurre un error al abrir el archivo se genera el mensaje de error especificado en la línea 16. En ausencia de errores el programa entra en un bucle while el cual está evaluado por efecto de la función miembro eof( ) de tal manera que el bucle se ejecuta hasta encontrar el final del archivo. Utlizando la función miembro getline( ) se obtiene una línea de texto y se exhibe en pantalla, línea 21, luego utilizamos una instrucción condicional if con el operador de módulo (%) para determinar si se han leído 24 líneas de texto. Cada vez que el contador de líneas dividido entre 24 dé como resultado un resíduo de cero el programa se detiene permitiendo leer las 24 líneas de texto previas. Para continuar se debe presionar la tecla enter y entonces el programa leerá y mostrará en pantalla las siguientes 24 líneas de texto, líneas 22 a la 26.

FUENTE: http://www.modelo.edu.mx/

Banderas de I/O y Manipuladores

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++. 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 librerías y .

(i) Banderas de formato:

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 despues 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 

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;
}

(2) Manipuladores

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 <<> 
La tabla que se muestra en seguida corresponde a los manipuladores definidos en .
 
 
Tabla I/O : 03, manipuladores en 
 
 
Manipulador
 
Descripción
 
Entrada
 
Salida
 
 
 
bollalpha
 
Activa la bandera boolalpha
 
X
 
X
 
 
 
dec
 
Activa la bandera dec-imal
 
X
 
X
 
 
 
endl
 
Escribe caracter de cambio de línea
 
---
 
X
 
 
 
ends
 
Escribe el caracter 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
 
 
 
hex
 
Activa la bandera oct-al
 
X
 
X
 
 
 
left
 
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 

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;
}
 
 
(3) Manipuladores de la libreria 'iomai....
Por último, y para terminar esta sección, hablaremos de los manipuladores definidos en la librería . 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 
 
 
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 caracter 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 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 
#include 
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;
}
FUENTE: http://es.wikibooks.org/wiki