¿Cómo ingresar, generar y leer archivos en C++?
C++ admite entrada y salida de archivos a través de las siguientes clases:
ofstream: clase de archivo para operaciones de escritura (salida) (derivada de ostream)
ifstream: archivo clase para operación de lectura (entrada) (derivada de istream)
fstream: clase de archivo que puede leer y escribir operaciones al mismo tiempo (derivada de iostream)
Abrir archivo (Abrir un file)
La primera operación que se realiza sobre un objeto de estas clases suele ser asociarlo a un archivo real, es decir, abrir un archivo. El archivo abierto está representado en el programa por un objeto de secuencia (una instancia de estas clases), y cualquier operación de entrada y salida realizada en este objeto de secuencia es en realidad operación realizada en el archivo.
Para abrir un archivo a través de un objeto de flujo, usamos su función miembro open():
void open (const char * nombre de archivo, modo modo abierto donde nombre de archivo es un carácter A); La cadena que representa el nombre del archivo que se va a abrir es una combinación de los siguientes identificadores:
ios::in abre el archivo para entrada (lectura)
ios::out para salida. (escribir) al abrir el archivo
ios::ate Posición inicial: final del archivo
ios::app Toda la salida se agrega al final del archivo
ios::trunc < 6a6 /td> Si el archivo ya existe, elimínelo primero
ios::binary modo binario
Estos identificadores se pueden usar en combinación con el Intervalo del operador "o" ( |). Por ejemplo, si queremos abrir el archivo "example.bin" en modo binario para escribir algunos datos, podemos llamar a la función miembro open() de la siguiente manera:
archivo ofstream;
file.open ("ejemplo.bin", ios::out | ios::app | ios::binary); ofstream, ifstream y fstream, todas las funciones miembro abiertas de estas clases incluyen una forma predeterminada de abrir archivos. , los modos predeterminados de estas tres clases son diferentes:
Modo predeterminado de los parámetros de clase
ofstream ios::out ios::trunc
ifstream ios : :in
fstream ios::in | ios::out
El valor predeterminado solo se utilizará si no se declaran parámetros de método cuando se llama a la función. Si la función se llama con algún parámetro declarado, los valores predeterminados se anularán por completo y no se combinarán con los parámetros de llamada.
Dado que la primera operación que se realiza sobre objetos de las clases ofstream, ifstream y fstream suele ser abrir un archivo, estas clases tienen un constructor que llama directamente a la función open con los mismos parámetros. De esta manera, podemos realizar las mismas operaciones de definición de objetos y apertura de archivos que las anteriores:
archivo ofstream ("ejemplo.bin", ios::out | ios::app | ios:: binario) ; Ambas formas de abrir archivos son correctas.
Puedes comprobar si un archivo se ha abierto correctamente llamando a la función miembro is_open():
bool 696 is_open() devuelve un valor booleano (bool), Verdadero significa el archivo se ha abierto correctamente, falso significa lo contrario.
Cerrar un archivo
Cuando se completan las operaciones de lectura y escritura del archivo, debemos cerrar el archivo para que vuelva a ser accesible. Para cerrar un archivo, debe llamar a la función miembro close(), que es responsable de descargar los datos en el caché y cerrar el archivo. Su formato es muy simple:
void close (); una vez que se llama a esta función, el objeto de flujo original se puede usar para abrir otros archivos y todos los demás procesos pueden volver a abrir el archivo.
Para evitar que el objeto de flujo se destruya mientras aún está asociado con el archivo abierto, el destructor llamará automáticamente a la función de cierre.
Archivos en modo texto
Las clases ofstream, ifstream y fstream se derivan de ostream, istream e iostream respectivamente. Es por eso que los objetos de fstream pueden usar miembros de su clase principal para acceder a los datos.
En términos generales, usaremos estas clases para realizar entradas y salidas con las mismas funciones miembro (cin y cout) que interactúan con la consola. Como se muestra en el siguiente ejemplo, utilizamos el operador de inserción sobrecargado <<:
// escribiendo en un archivo de texto
#include
archivo de ejemplo de flujo ("ejemplo.txt");
if (archivo de ejemplo.is_open()) {
archivo de ejemplo << “Esta es una línea. ";
archivo de ejemplo << "Esta es otra línea./n";
archivo de ejemplo.close();
}
return 0;
} file examp 687 le.txt
Esta es una línea.
Esta es otra línea
Puedes. también lee datos de un archivo usando el mismo método que cin:
// leyendo un archivo de texto
#include
#include < fstream.h>
#include
búfer de caracteres[256];
ifstream archivo de ejemplo ( "ejemplo.txt ");
if (! examplefile.is_open())
{ cout << "Error al abrir el archivo"; salir (1); }
mientras (! examplefile.eof() ) {
examplefile.getline (buffer,100);
cout << buffer << endl;
}
return 0;
} Esta es una línea.
Esta es otra línea
El ejemplo anterior lee un archivo de texto y lo imprime. a la pantalla.
Tenga en cuenta que utilizamos una nueva función miembro llamada eof, que ifstream hereda de la clase ios y devuelve verdadero cuando se llega al final del archivo.
Verificación de indicadores de estado
Además de eof(), también hay algunas funciones miembro que verifican el estado de la secuencia (todas devuelven valores de retorno de tipo bool):
bad() devuelve verdadero si se produce un error durante la lectura y escritura. Por ejemplo: cuando queremos escribir en un archivo que no está abierto para escritura, o cuando el dispositivo en el que queremos escribir no tiene espacio restante.
Además de devolver verdadero en la misma situación que bad(), fail() también devuelve verdadero cuando hay un error de formato, como cuando quieres leer un número entero y obtener una letra.
eof() devuelve verdadero si el archivo leído llega al final del archivo.
good() Esto es lo más general: si llamar a cualquiera de las funciones anteriores devuelve verdadero, esta función devuelve falso.
Para restablecer los indicadores de estado marcados por las funciones miembro anteriores, puede utilizar la función miembro clear() sin parámetros.
Obtener y colocar punteros de flujo
Todos los objetos de flujo de entrada/salida (objetos de flujo de E/S) tienen al menos un puntero de flujo:
ifstream, como istream , tiene un puntero llamado puntero de obtención, que apunta al siguiente elemento a leer.
ofstream, similar a ostream, tiene un puntero que apunta a la ubicación donde se escribe el siguiente elemento.
fstream, similar a iostream, hereda get y put.
Podemos leer o configurar estos punteros de flujo que apuntan a ubicaciones de lectura y escritura en el flujo usando las siguientes funciones miembro:
p>
Las dos funciones miembro tellg() y tellp() no necesitan pasar parámetros y devolver un valor de tipo pos_type (según el estándar ANSI-C++), que es un número entero. que representa la posición del puntero de flujo de obtención actual (usando tellg) O coloque la posición del puntero de flujo (use tellp
El par de funciones seekg() y seekp() se utilizan para cambiar las posiciones). de los punteros de flujo get y put respectivamente. Ambas funciones están sobrecargadas con dos prototipos diferentes:
seekg (pos_type position);
seekp (pos_type position);
Utilice este prototipo, el puntero de flujo es cambiado para apuntar a una posición absoluta calculada desde el principio del archivo. Se requiere que el tipo de parámetro pasado sea el mismo que el tipo de valor de retorno de las funciones tellg y tellp.
seekg (desplazamiento fuera de tipo, dirección de búsqueda) 63f;
seekp (desplazamiento fuera de tipo, dirección de búsqueda);
Utilice este prototipo para especificar la dirección determinada por el parámetro Un desplazamiento (desplazamiento) en el que se comienza a calcular un puntero específico. Puede ser:
ios::beg Desplazamiento desde el inicio de la secuencia
ios::cur Desplazamiento desde la posición actual del puntero de la secuencia
ios ::end El desplazamiento calculado desde el final de la secuencia
Los valores de los punteros de secuencia get y put se calculan de manera diferente para archivos de texto y archivos binarios debido al modo de texto Algunos caracteres especiales en el archivo puede ser modificado.
Por esta razón, se recomienda utilizar siempre el primer prototipo de seekg y seekp para archivos abiertos en modo de archivo de texto, y no modificar los valores de retorno de tellg o tellp. Para los binarios, puedes usar estas funciones como quieras y no debería haber ningún comportamiento inesperado.
El siguiente ejemplo utiliza estas funciones para obtener el tamaño de un archivo binario:
//obtener el tamaño del archivo
#include #include long l,m; archivo ifstream ( nombre de archivo, ios::in|ios::binary); l = file.tellg(); file.seekg (0, ios::end); m = file.tellg(); file.clo 639 se(); cout << “tamaño de ” << nombre de archivo; cout << ” es ” << (m-l) << ” bytes./n”; devuelve 0; } tamaño de ejemplo.txt tiene 40 bytes. Archivos binarios En archivos binarios, use << y >>, así como funciones (como getline) para operar los datos de entrada y salida. No tienen ningún significado práctico, aunque son gramaticales. El flujo de archivos incluye dos funciones miembro especialmente diseñadas para la lectura y escritura secuencial de datos: escritura y lectura. La primera función (escritura) es una función miembro de ostream, que es heredada por ofstream. Y leer es una función miembro de istream, heredada por ifstream. Los objetos de clase fstream tienen ambas funciones. Sus prototipos son: escribir (char * buffer, tamaño de flujo); leer (char * buffer, tamaño de flujo); Aquí el buffer es un bloque. La dirección de la memoria utilizada para almacenar o leer datos. El tamaño del parámetro es un valor entero que representa el número de caracteres que se leerán o escribirán desde el búfer. // leyendo archivo binario #include #include char * buffer; tamaño largo; archivo ifstre 600 am (nombre de archivo, ios::in|ios::binary|ios ::ate); tamaño = file.tellg(); file.seekg (0, ios::beg); búfer = nuevo carácter [tamaño]; file.read (buffer, tamaño); file.close();cout << “el archivo completo está en un buffer”;eliminar[] buffer ; return 0; }El archivo completo está en un buffer Caché y Sincronización (Buffers y Sincronización) p> Cuando operamos en secuencias de archivos, están asociadas con un búfer de tipo streambuf. Este búfer es en realidad un espacio de memoria que sirve como medio para transmisiones y archivos físicos. Por ejemplo, para una secuencia de salida, cada vez que se llama a la función miembro put (escribe un solo carácter), este carácter no se escribe directamente en el archivo físico correspondiente a la secuencia de salida, sino que primero se inserta en el búfer de la secuencia ( buffer). Cuando se vacía el caché, todos los datos que contiene se escriben en el medio físico (si se trata de un flujo de salida) o simplemente se borran (si se trata de un flujo de palabras de entrada). Este proceso se llama sincronización y ocurre en cualquiera de las siguientes situaciones: Cuando se cierra el archivo: se sincronizarán todos los buffers que no se hayan escrito o leído por completo antes de cerrar el archivo. Cuando el buffer de caché está lleno: Los Buffers de caché tienen ciertas limitaciones de espacio. Cuando el caché está lleno, se sincroniza 583 automáticamente. Los caracteres de control indican claramente que la sincronización se producirá cuando se encuentren ciertos caracteres de control en la secuencia. Estos caracteres de control incluyen: rubor y endl. Llamar explícitamente a la función sync(): llamar a la función miembro sync() (sin parámetros) puede desencadenar una sincronización inmediata. Esta función devuelve un valor int, igual a -1 para indicar que la secuencia no tiene caché asociada o que la operación falló. /xwj102/article/details/2605410