Acciones con archivos en c. Trabajar con archivos de texto
La función fopen() abre una secuencia para su uso, asocia un archivo con esa secuencia y luego devuelve un puntero ARCHIVO a esa secuencia. La mayoría de las veces, el archivo se trata como un archivo de disco. La función fopen() tiene el siguiente prototipo:
ARCHIVO *fopen(const char *nombre de archivo, const char *modo);
Donde modo apunta a una cadena que contiene el modo deseado para abrir el archivo. Los valores válidos para el modo en Borland C++ se muestran en la tabla. nombre de archivo debe ser una cadena de caracteres que proporcione un nombre de archivo válido para el sistema operativo y puede contener una ruta de acceso.
La función fopen() devuelve un puntero al tipo base ARCHIVO. Este puntero identifica el archivo y lo utilizan la mayoría de las funciones del sistema de archivos. Nunca debes cambiarlo tú mismo. La función devuelve un puntero nulo si el archivo no se puede abrir.
Como muestra la tabla, el archivo se puede abrir en modo texto o binario. En modo texto, a medida que escribe, la secuencia de retornos de carro y avances de línea se traduce en un carácter de nueva línea. En la salida, ocurre lo contrario: el carácter de nueva línea se traduce en un retorno de carro y un avance de línea. Esta traducción no ocurre en archivos binarios. Cuando no se especifica ni t ni b en el argumento modo, el estado de texto/binario del archivo está determinado por el valor de la variable global _fmode definida en Borland C++. De forma predeterminada, fmode está configurado en O_TEXT, es decir, el modo de texto está configurado. Si configura _fmode en O_BINARY, los archivos se abrirán en modo binario. (Estas macros se definen en fcntl.h.) Naturalmente, el uso de una t o b explícita elimina los efectos asociados con la variable _fmode. Además, _fmode es específico únicamente de los productos Borland. No está definido en el sistema de E/S ANSI C.
Si necesita abrir un archivo llamado prueba para escribir, debe escribir:
Fp = fopen("prueba", "w");
Donde fp es una variable de tipo ARCHIVO *. Sin embargo, es común ver lo siguiente:
If((fp = fopen("prueba", "w"))==NULL) (
puts("No se puede abrir el archivo.");
salir(1);
}
Este método le permite detectar errores al abrir un archivo, por ejemplo, la presencia de protección contra escritura o falta de espacio libre en el disco.
Si se utiliza fopen() para abrir un archivo para escribir, se eliminará cualquier archivo preexistente con el nombre especificado. Si un archivo con el nombre especificado no existe, se creará.
Si necesita agregar información al final del archivo, debe usar el modo a (adjuntar). Si el archivo no existe, se creará.
Abrir un archivo para leer requiere la presencia del archivo. Si el archivo no existe, se devolverá un error. Si se abre un archivo para operación de lectura/escritura, no se elimina si existe, y si el archivo no existe, se crea.
|
Significado |
|
|---|---|
|
Abre un archivo para leer. (Se abre de forma predeterminada como un archivo de texto). |
|
|
Crea un archivo para escribir. (Se abre de forma predeterminada como un archivo de texto). |
|
|
Se adjunta a un archivo. (Se abre de forma predeterminada como un archivo de texto). |
|
|
Abre un archivo binario para leer. |
|
|
Abre un archivo binario para escribir. |
|
|
Se adjunta a un archivo binario. |
|
|
Abre un archivo para lectura/escritura. (Se abre de forma predeterminada como un archivo de texto). |
|
|
Crea un archivo de lectura/escritura. (Se abre de forma predeterminada como un archivo de texto). |
|
|
Adjunta o crea un archivo de lectura/escritura. (Se abre de forma predeterminada como un archivo de texto). |
|
|
Abre un archivo binario para lectura/escritura. |
|
|
Crea un archivo binario de lectura/escritura. |
|
|
Adjunta o crea un archivo binario de lectura/escritura. |
|
|
Crea un archivo de texto para escribir. |
|
|
Se adjunta a un archivo de texto. |
|
|
Abre un archivo de texto para leer. |
|
|
Crea un archivo de texto para lectura/escritura. |
|
|
Abre o crea un archivo de texto para lectura/escritura. |
Trabajar con archivos de texto en C++.
Hay dos tipos principales de archivos: de texto y binarios. Los archivos permiten al usuario leer grandes cantidades de datos directamente desde el disco sin tener que ingresarlos desde el teclado.
Texto Se llaman archivos que constan de cualquier carácter. Están organizados en líneas y cada una termina con un carácter de fin de línea. El final del archivo en sí se indica con el símbolo de "fin de archivo". Al escribir información en un archivo de texto, que se puede ver con cualquier editor de texto, todos los datos se convierten a un tipo de carácter y se almacenan en forma de caracteres.
EN binario En los archivos la información se lee y escribe en forma de bloques de un determinado tamaño, en los que se pueden almacenar datos de cualquier tipo y estructura.
Para trabajar con archivos, especiales. tipos de datos, llamado corrientes. Fluir si corriente se utiliza para trabajar con archivos en modo lectura, y ofstream en modo de grabación. Para trabajar con archivos tanto en modo de escritura como de lectura, se utiliza una secuencia fstream.
En programas C++, cuando se trabaja con archivos de texto, se deben incluir las bibliotecas iostream y fstream.
Con el fin de anote datos a un archivo de texto, necesita:
describir una variable de tipo de flujo.
enviar información a un archivo.
asegúrese de cerrar el archivo.
Para lectura datos de un archivo de texto, necesita:
describir una variable de tipo ifstream.
abra un archivo usando la función abrir.
cerrar el archivo.
Registro información a un archivo de texto
Como se mencionó anteriormente, para comenzar a trabajar con un archivo de texto, debe definir una variable de tipo flujo. Por ejemplo, así:
Se creará una variable F para escribir información en el archivo.
En la siguiente etapa, el expediente debe abrirse para su escritura. En general, el operador de apertura de flujo tendrá el siguiente aspecto:
F.open("archivo", modo);
Aquí F es una variable descrita como ofstream,
archivo: nombre completo del archivo en el disco,
modo: modo de trabajar con el archivo que se está abriendo.
Tenga en cuenta que al especificar el nombre completo del archivo, debe utilizar una doble barra. Por ejemplo, el nombre completo del archivo noobs.txt, ubicado en la carpeta del juego en la unidad D:, deberá escribirse así:
D:\\juego\\noobs.txt.
El archivo se puede abrir en uno de los siguientes modos:
ios::in: abre el archivo en modo de lectura de datos, este modo es el modo predeterminado para ifstreams;
ios::out: abre un archivo en modo de escritura de datos (en este caso, se destruye la información sobre el archivo existente), este modo es el modo predeterminado para ofstreams;
ios::app: abre el archivo en el modo de escritura de datos hasta el final del archivo;
ios::ate: va al final de un archivo ya abierto;
ios::trunc - borra el archivo, esto también sucede en el modo ios::out;
ios::nocreate - no abre un archivo si no existe;
ios::noreplace: no abre un archivo existente.
Es posible que el parámetro de modo esté ausente, en cuyo caso el archivo se abre en el modo predeterminado para esta secuencia.
Después de abrir exitosamente el archivo (en cualquier modo), la variable F almacenará verdadero; de lo contrario, será falso. Esto le permitirá comprobar la exactitud de la operación de apertura del archivo.
Puedes abrir un archivo (tomemos el archivo D:\\game\\noobs.txt como ejemplo) en modo de grabación de una de las siguientes maneras:
// primero forma
de la corriente F;
F.open("D:\\juego\\noobs.txt", ios::out);
//segundo método, el modo ios::out es el modo predeterminado
// Para fluirofstream
de la corriente F;
//el tercer método combina la descripción de la variable y el tipo de flujo
//y abriendo el archivo en una sola declaración
ofstream F("D:\\juego\\noobs.txt", ios::out);
Después de abrir un archivo en modo de escritura, se creará un archivo vacío en el que podrá escribir información.
Si desea abrir un archivo existente en modo de escritura anterior, debe usar ios::app como modo.
Después de abrir un archivo en modo de grabación, puede escribir en él de la misma manera que en la pantalla, solo que en lugar del dispositivo de salida estándarcortedebe especificar el nombre del archivo abierto.
Por ejemplo, para escribir la variable a en el flujo F, la declaración de salida tendrá el siguiente aspecto:
Para la salida secuencial al flujo G de las variables b, c, d, el operador de salida será así:
GRAMO< El cierre de una secuencia se realiza mediante el operador: EJEMPLO: Crea un archivo de texto D:\\game\\noobs.txt y escribe n números reales en él. #incluir "stdafx.h" #incluir #incluir #incluir usando el espacio de nombres estándar; int principal() setlocale(LC_ALL, "RUS"); int i, n; doble a; //describe una secuencia para escribir datos en un archivo ofstream
F;
//abre el archivo en modo escritura, //modoios::
afuerainstalado por defecto f.open("D:\\juego\\noobs.txt", ios::out); //ingresa el número de números reales corte<<"
norte=";
cin>>
norte;
//bucle para ingresar números reales //y escribirlos en un archivo para (i=0; yo corte<<"a=";
//Ingrese un numero cin>>a; F< //cerrando la transmisión f.cerrar(); sistema("pausa"); devolver 0; _______________________________________________________________ Para leer información de un archivo de texto, necesita describir una variable como si corriente. Después de esto, debe abrir el archivo para leerlo usando el operador abierto. Si la variable se llama F, entonces las dos primeras declaraciones serán así: F.open("D:\\juego\\noobs.txt", ios::in); Después de abrir un archivo en modo lectura, puede leer información del mismo de la misma manera que desde el teclado, solo que en lugar decinespecifique el nombre de la secuencia desde la cual se leerán los datos. Por ejemplo, para leer del flujo F a la variable a, la declaración de entrada se vería así: Dos números en un editor de texto se consideran separados si hay al menos uno de los caracteres entre ellos: espacio, tabulación, final de línea. Es bueno que el programador sepa de antemano cuántos y qué valores almacenar en el archivo de texto. Sin embargo, a menudo el tipo de valores almacenados en el archivo simplemente se conoce, pero su número puede variar. Para resolver este problema, debe leer los valores del archivo uno por uno y, antes de cada lectura, verificar si se ha llegado al final del archivo. Hay una función para esto. F.
eof().
Aquí F es el nombre del hilo, la función devuelve un valor booleano: verdadero o falso, dependiendo de si se llega al final del archivo. Por lo tanto, un bucle para leer el contenido de todo el archivo se puede escribir así: //organizar para leer valores de un archivo, ejecución //el bucle se romperá cuando lleguemos al final del archivo, //en este caso F.eof() devolverá verdadero mientras (!F.eof()) EJEMPLO: El archivo de texto D:\\game\\noobs.txt almacena números reales, los muestra en la pantalla y calcula su número. #incluir "stdafx.h" #incluir #incluir #incluir #incluir usando el espacio de nombres estándar; int principal() setlocale(LC_ALL, "RUS"); entero n=0; flotar un; fstream F; //abre el archivo en modo lectura F.open("D:\\juego\\noobs.txt"); //si el archivo se abrió correctamente, entonces //bucle para leer valores de un archivo; la ejecución del bucle se interrumpirá, //cuando lleguemos al final del archivo, en este caso F.eof() devolverá verdadero. mientras (!F.eof()) //leyendo el siguiente valor del flujo F en la variable a F>>a; //muestra el valor de la variable a en la pantalla corte< //aumentar el número de números leídos //cerrando la transmisión F.cerrar(); //ingresamos en la pantalla el número de números leídos corte<<"n="< //si la apertura del archivo fue incorrecta, entonces la salida //mensajes sobre la ausencia de dicho archivo más cout<<" Файл не существует"< sistema("pausa"); devolver 0; C++. Procesamiento de archivos binarios Al escribir información en un archivo binario, los caracteres y números se escriben como una secuencia de bytes. Con el fin de anote datos a un archivo binario, necesita: describir una variable de archivo de tipo FAIL * usando el operador FILE *filename; Aquí nombre de archivo es el nombre de la variable donde se almacenará el puntero al archivo. escribir información en un archivo usando la función fwrite Con el fin de considerar b datos de un archivo binario, debe: describir una variable de tipo ARCHIVO * abrir un archivo usando la función fopen cerrar un archivo usando la función fclose Funciones básicas necesarias para trabajar con archivos binarios. Para descubrimientos El archivo está destinado a la función fopen. ARCHIVO *fopen(const *nombre de archivo, const char *modo) Aquí nombre de archivo es una cadena que almacena el nombre completo del archivo que se abre, modo es una cadena que determina el modo de trabajar con el archivo; son posibles los siguientes valores: “rb” - abre el archivo binario en modo lectura; “wb”: crea un archivo binario para grabar; si existe, se borra su contenido; “ab”: crea o abre un archivo binario para agregarlo al final del archivo; “rb+” - abre un archivo binario existente en modo lectura-escritura; “wb+” - abre el archivo binario en modo lectura-escritura, el archivo existente se borra; "ab+": se abre o crea un archivo binario para corregir la información existente y agregar nueva información al final del archivo. La función devuelve NULL en la variable del archivo f si el archivo se abre sin éxito. Después de abrir un archivo, su 0º byte está disponible, el puntero del archivo es 0, cuyo valor, a medida que se lee o escribe, se desplaza según el número de bytes leídos (escritos). El valor actual del puntero del archivo es el número de byte a partir del cual se producirá la operación de lectura o escritura. Para clausura el archivo está destinado a la función fclose int fclose(ARCHIVO *nombre de archivo); Devuelve 0 si el archivo se cerró correctamente, NULL en caso contrario. La función de eliminación es para eliminación archivos. int remove(const char *nombre de archivo); Esta función elimina un archivo llamado filenema del disco. El archivo a eliminar debe estar cerrado. La función devuelve un valor distinto de cero si el archivo no se pudo eliminar. Para renombrar archivos, la función de cambio de nombre está destinada a: int rename(const char *nombre de archivo antiguo, const char *nombre de archivo nuevo); El primer parámetro es el nombre del archivo antiguo, el segundo es el nuevo. Devuelve 0 si el programa termina exitosamente. Lectura desde un archivo binario se realiza usando la función fread: fread(void *ptr, tamaño, n, ARCHIVO *nombre de archivo); La función fread lee n elementos de tamaño del nombre del archivo en una matriz ptr. La función devuelve el número de elementos leídos. Después de leer un archivo, su puntero se desplaza en n*bytes de tamaño. Registro a un archivo binario se realiza usando la función fwrite: fwrite(const void *ptr, tamaño, n, ARCHIVO *nombre de archivo); La función fwrite escribe en el nombre del archivo desde una matriz ptr de n elementos de tamaño. La función devuelve el número de elementos escritos. Después de escribir información en el archivo, el puntero se desplaza n*bytes de tamaño. Para control de fin de archivo hay una función feof: int feof(ARCHIVO *nombre de archivo); Devuelve un valor distinto de cero si se llega al final del archivo. EJEMPLO: Cree un archivo binario D:\\game\\noobs.dat y escriba n números enteros y n reales en él. #incluir "stdafx.h" #incluir usando el espacio de nombres estándar; int principal() setlocale(LC_ALL, "RUS"); int norte, yo; doble a; //crea un archivo binario en modo escritura f=fopen("D:\\juego\\noobs.dat", "wb"); //
aporte
númerosnorte corte<<"n=";
cin>>norte; fwrite(&n, tamaño de(int), 1, f); //bucle para ingresar n números reales para (i=0; yo //ingresa el siguiente número real corte<<"a=";
cin>>a; //escribiendo un número real en un archivo binario fwrite(&a, tamaño de(doble), 1, f); //
cerca
archivo cerrar(f); sistema("pausa"); devolver 0; EJEMPLO: Muestra el contenido del archivo binario D:\\game\\noobs.dat creado en la tarea anterior #incluir "stdafx.h" #incluir usando el espacio de nombres estándar; int principal() setlocale(LC_ALL, "RUS"); int norte, yo; doble a; ARCHIVO *f; //describe la variable del archivo //abre el archivo binario existente en modo lectura //lee un entero del archivo en la variable n //salida n a la pantalla corte<<"n="< //asignando memoria para una matriz de n números a=nuevo doble[n]; //leer n números reales del archivo en la matriz a //muestra la matriz a la pantalla para (i=0; yo corte< corte< //
cerca
archivo cerrar(f); sistema("pausa"); devolver 0; Archivo binario- estructura de datos secuencial, después de abrir un archivo, el primer byte almacenado en él está disponible. Puede escribir o leer datos de un archivo de forma secuencial. Digamos que necesitas contar el decimoquinto número y luego el primero. Usando el acceso secuencial esto se puede hacer de la siguiente manera: int norte, yo; doble a; ARCHIVO *f; f=fopen("D:\\juego\\noobs.dat", "rb"); para (i=0; yo<15; i++)
cerrar(f); f=fopen("D:\\juego\\noobs.dat", "rb"); fread(&a, tamaño de(doble), 1, f); cerrar(f); Como puede ver, leer números de un archivo y luego abrirlo nuevamente no es la forma más conveniente. Será mucho más conveniente utilizar la función fseek para mover el puntero del archivo a un byte determinado. int fseek(ARCHIVO *nombre de archivo, desplazamiento int largo, origen int); La función establece el puntero de posición del archivo actual F de acuerdo con los valores de origen y desplazamiento. El parámetro de desplazamiento es igual al número de bytes en los que el puntero del archivo se desplazará con respecto al origen especificado por el parámetro de origen. El valor del parámetro de origen debe ser uno de los siguientes valores de desplazamiento definidos en el encabezado stdio.h: SEEK_SET - desde el principio del archivo; SEEK_CUR - desde la posición actual; SEEK_END: desde el final del archivo. La función devuelve un valor cero si la operación fue exitosa, distinto de cero si ocurrió una falla durante la ejecución del desplazamiento. La función fseek en realidad implementa el acceso directo a cualquier valor de un archivo. Sólo necesita saber la ubicación (número de byte) del valor en el archivo. Veamos el uso del acceso directo en archivos binarios usando el siguiente problema como ejemplo. EJEMPLO En el archivo binario D:\\game\\noobs.dat creado anteriormente, intercambie los números reales más grandes y más pequeños. El algoritmo para resolver el problema consta de las siguientes etapas: leer reales de un archivo en la matriz a. busque en la matriz a los valores máximo (max) y mínimo (min) y sus números (imax, imin). moviendo el puntero del archivo al valor máximo y escribiendo min. moviendo el puntero del archivo al valor mínimo y escribiendo max. A continuación se muestra el texto del programa para resolver el problema con comentarios. #incluir "stdafx.h" #incluir usando el espacio de nombres estándar; int principal() setlocale(LC_ALL, "RUS"); int n, i, imax, imin; doble *a, máximo, mínimo; ARCHIVO *f; //abre un archivo en modo lectura-escritura f=fopen("D:\\juego\\noobs.dat", "rb+"); //leer el número del archivo a la variable n //números reales en el archivo fread(&n, tamaño de(int), 1, f); corte<<"n="< //asigna memoria para almacenar números reales, //que se almacenará en la matriz a a=nuevo doble[n]; //leer del archivo en matriz y números reales fread(a, tamaño de(doble), n, f); //busca elementos máximos y mínimos //en el array a y sus índices para (imax=imin=0, max=min=a, i=1; i si (a[i]>max) máximo=a[i]; si (un[i] mín=a[i]; //
Moviente
puntero
A
máximo
elemento fseek(f, tamaño de (int)+imax*tamaño de (doble), SEEK_SET); //escribe el elemento de archivo mínimo en lugar del máximo fwrite(&min, tamaño de(doble), 1, f); //
Moviente
puntero
A
mínimo
elemento fseek(f, tamaño de (int)+imin*tamaño de (doble), SEEK_SET); //registro máximo en lugar del elemento de archivo mínimo fwrite(&max, tamaño de(doble), 1, f); //cerrando el archivo cerrar(f); //memoria libre borrar [
]a; sistema("pausa"); Etiquetas: Archivos de texto, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, flujo almacenado en búfer, flujo sin búfer. Trabajar con un archivo de texto es similar a trabajar con la consola: usando funciones de entrada formateadas guardamos datos en un archivo, usando funciones de salida formateadas leemos datos de un archivo. Hay muchos matices que veremos más adelante. Las principales operaciones que deben realizarse son Además, existen una serie de tareas en las que no necesitamos acceder al contenido del archivo: renombrar, mover, copiar, etc. Desafortunadamente, el estándar C no contiene una descripción de funciones para estas necesidades. Por supuesto, están disponibles para cada una de las implementaciones del compilador. Leer el contenido de un directorio (carpeta, directorio) también es acceder a un archivo, porque la carpeta en sí es un archivo con metainformación. A veces es necesario realizar algunas operaciones auxiliares: desplazarse a la ubicación deseada en el archivo, recordar la posición actual, determinar la longitud del archivo, etc. Para trabajar con un archivo, necesita un objeto ARCHIVO. Este objeto almacena el identificador del flujo de archivos y la información necesaria para administrarlo, incluido un puntero a su búfer, un indicador de posición del archivo e indicadores de estado. El objeto ARCHIVO es en sí mismo una estructura, pero no se debe acceder a sus campos. El programa portátil debe tratar el archivo como un objeto abstracto que permite el acceso al flujo del archivo. La creación y asignación de memoria para un objeto de tipo ARCHIVO se realiza mediante la función fopen o tmpfile (hay otras, pero nos centraremos solo en estas). La función fopen abre un archivo. Recibe dos argumentos: una cadena con la dirección del archivo y una cadena con el modo de acceso al archivo. El nombre del archivo puede ser absoluto o relativo. fopen devuelve un puntero a un objeto ARCHIVO que se puede utilizar para acceder más al archivo. ARCHIVO* fopen(const char* nombre de archivo, const char* modo); Por ejemplo, abramos un archivo y escribamos Hola mundo en él. #incluir La propia función fopen asigna memoria para el objeto; la limpieza la realiza la función fclose. Es necesario cerrar el archivo; no se cerrará por sí solo. La función fopen puede abrir un archivo en modo texto o binario. El valor predeterminado es texto. El modo de acceso puede ser el siguiente Si es necesario abrir el archivo en modo binario, entonces se agrega la letra b al final de la línea, por ejemplo “rb”, “wb”, “ab” o, para modo mixto, “ab+”, “ wb+”, “ab+”. En lugar de b, puede agregar la letra t, luego el archivo se abrirá en modo texto. Depende de la implementación. En el nuevo estándar C (2011), la letra x significa que fopen debería fallar si el archivo ya existe. Complementemos nuestro programa anterior: vuelva a abrir el archivo y considere lo que escribimos allí. #incluir En lugar de la función fgets, puedes usar fscanf, pero debes recordar que solo puede leer la línea hasta el primer espacio. Además, en lugar de abrir y cerrar un archivo, puede utilizar la función freopen, que "vuelve a abrir" el archivo con nuevos derechos de acceso. #incluir Las funciones fprintf y fscanf se diferencian de printf y scanf solo en que toman como primer argumento un puntero al ARCHIVO al que generarán o del que leerán datos. Vale la pena agregar de inmediato que las funciones printf y scanf pueden reemplazarse fácilmente por las funciones fprintf y fscanf. En el sistema operativo (estamos considerando los sistemas operativos más comunes y adecuados) hay tres flujos estándar: flujo de salida estándar stdout, flujo de entrada estándar stdin y flujo de salida de error estándar stderr. Se abren automáticamente cuando se inicia la aplicación y están asociados con la consola. Ejemplo #incluir Si la llamada a la función fopen falla, devolverá NULL. Los errores al trabajar con archivos ocurren con bastante frecuencia, por lo que cada vez que abrimos un archivo debemos verificar el resultado del trabajo. #incluir El problema surge cuando se abren varios archivos a la vez: si uno de ellos no se puede abrir, entonces el resto también se debe cerrar ARCHIVO *archivodeentrada, *archivodesalida; m, n sin firmar; sin firmar i, j; archivo de entrada = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) ( printf("Error al abrir el archivo %s", INPUT_FILE); getch(); exit(3); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) ( printf("Error al abrir el archivo %s", OUTPUT_FILE); getch(); if (inputFile != NULL) ( fclose(inputFile); ) exit(4); ) ... En casos simples, puede actuar de frente, como en el código anterior. En casos más complejos, se utilizan métodos que reemplazan a RAII de C++: contenedores o funciones del compilador (limpieza en GCC), etc. Como se mencionó anteriormente, cuando generamos datos, primero se colocan en un búfer. El búfer se borra Puede forzar la descarga del búfer llamando a la función fflush(File *). Veamos dos ejemplos: con y sin limpieza. #incluir Descomente la llamada de descarga. En tiempo de ejecución, abra el archivo de texto y observe el comportamiento. Puede asignar un búfer de archivos usted mismo configurando su propio tamaño. Esto se hace usando la función Void setbuf(FILE * stream, char * buffer); que toma un ARCHIVO ya abierto y un puntero a un nuevo búfer. El tamaño del nuevo buffer no debe ser menor que BUFSIZ (por ejemplo, en la estación de trabajo actual BUFSIZ es de 512 bytes). Si pasa NULL como búfer, la transmisión deja de tener búfer. También puedes usar la función Int setvbuf(FILE * stream, char * buffer, modo int, size_t tamaño); que acepta un búfer de tamaño arbitrario. El modo puede tomar los siguientes valores. Ejemplo: configuremos nuestro propio buffer y veamos cómo se realiza la lectura de un archivo. Dejamos que el archivo sea corto (algo así como ¡Hola, mundo!), y lo leemos carácter por carácter. #incluir Se puede ver que los datos ya están en el búfer. La lectura carácter por carácter se realiza desde el búfer. Función int feof(ARCHIVO * flujo); devuelve verdadero si se llega al final del archivo. La función es cómoda de utilizar cuando necesita revisar todo el archivo de principio a fin. Deje que haya un archivo con contenido de texto text.txt. Leemos el archivo carácter a carácter y lo mostramos en pantalla. #incluir Todo estaría bien, pero la función feof no funciona correctamente... Esto se debe a que el concepto de “fin de archivo” no está definido. Un error que ocurre a menudo al usar feof es que los últimos datos leídos se imprimen dos veces. Esto se debe al hecho de que los datos se escriben en el búfer de entrada, la última lectura ocurre con un error y la función devuelve el valor anterior leído. #incluir Este ejemplo fallará (lo más probable) e imprimirá el último carácter del archivo dos veces. La solución es no utilizar feof. Por ejemplo, almacene el número total de registros o utilice el hecho de que las funciones fscanf, etc. generalmente devuelven el número de valores leídos y coincidentes correctamente. #incluir 1. Un archivo contiene dos números: las dimensiones de la matriz. Llenemos el segundo archivo con una matriz de números aleatorios. #incluir 2. El usuario copia el archivo y primero selecciona el modo de funcionamiento: el archivo se puede enviar a la consola o copiar a un archivo nuevo. #incluir 3. El usuario ingresa datos desde la consola y se escriben en un archivo hasta que se presiona la tecla esc. Mira el programa y compruébalo. cómo se comporta si ingresa la tecla de retroceso: qué se envía al archivo y qué se envía a la consola. #incluir 4. El archivo contiene números enteros. Encuentra el máximo de ellos. Aprovechemos el hecho de que la función fscanf devuelve el número de objetos leídos y coincidentes correctamente. El número 1 debe devolverse cada vez. #incluir Otra solución es leer números hasta llegar al final del archivo. #incluir 5. El archivo contiene palabras: palabra rusa, tabulación, palabra inglesa, en varias filas. El usuario ingresa una palabra en inglés, es necesario mostrar la rusa. El archivo de traducción se parece a esto sol Sol y guardado en codificación cp866 (OEM 866). Es importante: el último par de palabras también termina con un salto de línea. El algoritmo es el siguiente: leemos una línea de un archivo, buscamos un carácter de tabulación en la línea, reemplazamos el carácter de tabulación con un cero, copiamos una palabra rusa del búfer, copiamos una palabra en inglés del búfer, verificamos la igualdad. #incluir 6. Cuente el número de líneas del archivo. Leeremos el archivo carácter por carácter, contando el número de caracteres "\n" hasta encontrar el carácter EOF. EOF es un carácter especial que indica que la entrada está completa y no hay más datos para leer. La función devuelve un valor negativo en caso de error. #definir _CRT_SECURE_NO_WARNINGS #incluir Ru-Cyrl 18-tutorial Sypachev S.S. 1989-04-14 [correo electrónico protegido] Stepán Sypachev estudiantes ¿Aún no lo tienes claro? – escribir preguntas al buzón Para el programador, un archivo abierto se representa como una secuencia de datos que se leen o escriben. Cuando se abre un archivo, se asocia con flujo de E/S
. La información de salida se escribe en la secuencia, la información de entrada se lee de la secuencia. Cuando se abre una secuencia para E/S, se asocia con una estructura de ARCHIVO estándar, que se define en stdio.h. La estructura ARCHIVO contiene la información necesaria sobre el archivo. La apertura de un archivo se realiza mediante la función fopen(), que devuelve un puntero a una estructura de tipo ARCHIVO que se puede utilizar para operaciones posteriores en el archivo. ARCHIVO *fopen(nombre, tipo); nombre: nombre del archivo a abrir (incluida la ruta), · "r" - abre el archivo para leerlo (el archivo debe existir); · "w" - abre un archivo vacío para escribir; si el archivo existe, su contenido se pierde; · "a" - abre el archivo para escribirlo hasta el final (para agregarlo); el archivo se crea si no existe; · "r+" - abre el archivo para lectura y escritura (el archivo debe existir); · "w+" - abre un archivo vacío para lectura y escritura; si el archivo existe, su contenido se pierde; · "a+" - abre el archivo para leerlo y agregarlo; si el archivo no existe, se crea. El valor de retorno es un puntero a la secuencia abierta. Si se detecta un error, se devuelve NULL. La función fclose() cierra la secuencia o secuencias asociadas con los archivos abiertos usando la función fopen(). La secuencia que se cerrará está determinada por el argumento de la función fclose(). Valor de retorno: valor 0 si la transmisión se cerró correctamente; EOF constante si ocurre un error. #incluir nombre char="mi.txt"; si(fp = fopen(nombre, "r")!=NULL) // ¿fue posible abrir el archivo? else printf("Error al abrir el archivo"); Leer un carácter de un archivo: char fgetc(corriente); El argumento de la función es un puntero a una secuencia de tipo ARCHIVO. La función devuelve el código del carácter leído. Si se llega al final del archivo o se produce un error, se devuelve la constante EOF. fputc(char, flujo); Los argumentos de la función son un carácter y un puntero a una secuencia de tipo ARCHIVO. La función devuelve el código del carácter leído. Las funciones fscanf() y fprintf() son similares a las funciones scanf() y printf(), pero funcionan con archivos de datos y tienen un puntero al archivo como primer argumento. fscanf(flujo, "Formato de entrada", argumentos); Las funciones fgets() y fputs() están diseñadas para entrada/salida de cadenas y son análogas a las funciones get() y puts() para trabajar con archivos. fgets(Puntero a línea, número de caracteres, secuencia); Los caracteres se leen de la secuencia hasta que se lee un carácter de nueva línea "\n", que está incluido en la cadena, o hasta que la secuencia finaliza EOF o se ha leído el número máximo de caracteres. El resultado se coloca en un puntero de cadena y termina con el carácter nulo "\0". La función devuelve la dirección de la cadena. fputs(Puntero a cadena, secuencia); Copia una cadena a la secuencia desde la posición actual. El carácter nulo final no se copia. Para facilitar el acceso, la información de los dispositivos de almacenamiento se almacena en forma de archivos. Un archivo es un área con nombre de memoria externa asignada para almacenar una matriz de datos. Los datos contenidos en los ficheros son de muy diversa naturaleza: programas en lenguaje algorítmico o de máquina; datos iniciales para la operación del programa o resultados de la ejecución del programa; textos libres; imágenes gráficas, etc. Directorio (carpeta, directorio): una colección de bytes con nombre en un medio de almacenamiento que contiene los nombres de subdirectorios y archivos, que se utiliza en el sistema de archivos para simplificar la organización de los archivos. Sistema de archivos Se llama parte funcional del sistema operativo que realiza operaciones en archivos. Ejemplos de sistemas de archivos son FAT (FAT - Tabla de asignación de archivos), NTFS, UDF (utilizado en CD). Hay tres versiones principales de FAT: FAT12, FAT16 y FAT32. Se diferencian en la profundidad de bits de los registros en la estructura del disco, es decir el número de bits asignados para almacenar el número del clúster. FAT12 se utiliza principalmente para disquetes (hasta 4 KB), FAT16 – para discos de pequeña capacidad, FAT32 – para unidades FLASH de alta capacidad (hasta 32 GB). Veamos la estructura del sistema de archivos usando FAT32 como ejemplo. Los dispositivos de memoria externa en el sistema FAT32 tienen direccionamiento de bloque en lugar de direccionamiento de byte. La información se escribe en un dispositivo de memoria externo en bloques o sectores. Un sector es la unidad mínima direccionable de almacenamiento de información en dispositivos de almacenamiento externos. Normalmente, el tamaño del sector se fija en 512 bytes. Para aumentar el espacio de direcciones de los dispositivos de memoria externos, los sectores se combinan en grupos llamados clusters. Un cluster es una unión de varios sectores, que pueden considerarse como una unidad independiente con determinadas propiedades. La principal propiedad de un clúster es su tamaño, medido en número de sectores o número de bytes. El sistema de archivos FAT32 tiene la siguiente estructura. Los grupos utilizados para escribir archivos se numeran a partir del 2. Como regla general, el directorio raíz utiliza el grupo número 2 y, a partir del grupo número 3, se almacena la matriz de datos. Los sectores utilizados para almacenar información sobre el directorio raíz no están agrupados. El sector de arranque comienza con la siguiente información: Además, el sector de arranque contiene la siguiente información importante: El sector de información del sistema de archivos contiene: La tabla FAT contiene información sobre el estado de cada clúster en el disco. Los 2 bytes inferiores de la tabla FAT almacenan F8 FF FF 0F FF FF FF FF (que corresponde al estado de los clústeres 0 y 1, que están físicamente ausentes). A continuación, el estado de cada clúster contiene el número del clúster en el que continúa el archivo actual o la siguiente información: El directorio raíz contiene un conjunto de registros de información de 32 bits sobre cada archivo, que contiene la siguiente información: Cuando se trabaja con nombres de archivos largos (incluidos nombres rusos), el nombre del archivo se codifica utilizando el sistema de codificación UTF-16. En este caso, se asignan 2 bytes para codificar cada carácter. En este caso, el nombre del archivo se escribe en la siguiente estructura: Para el programador, un archivo abierto se representa como una secuencia de datos que se leen o escriben. Cuando se abre un archivo, se asocia con flujo de E/S. La información de salida se escribe en la secuencia, la información de entrada se lee de la secuencia. Cuando se abre una secuencia para E/S, se asocia con una estructura de ARCHIVO estándar, que se define en stdio.h. La estructura ARCHIVO contiene la información necesaria sobre el archivo. La apertura de un archivo se realiza mediante la función fopen(), que devuelve un puntero a una estructura de tipo ARCHIVO que se puede utilizar para operaciones posteriores en el archivo. ARCHIVO *fopen(nombre, tipo); El valor de retorno es un puntero a la secuencia abierta. Si se encuentra un error, se devuelve NULL. La función fclose() cierra la secuencia o secuencias asociadas con los archivos abiertos usando la función fopen(). La secuencia que se cerrará está determinada por el argumento de la función fclose(). Valor de retorno: valor 0 si la transmisión se cerró correctamente; EOF constante si ocurre un error. 1 #incluir Leer un carácter de un archivo: char fgetc(corriente); Escribir un símbolo en un archivo: fputc(char, flujo); Los argumentos de la función son un carácter y un puntero a una secuencia de tipo ARCHIVO. La función devuelve el código del carácter leído. Las funciones fscanf() y fprintf() son similares a las funciones scanf() y printf(), pero funcionan con archivos de datos y tienen un puntero al archivo como primer argumento. fscanf(flujo, "InputFormat", argumentos); Trabajar con archivos de texto
Opciones de acceso a archivos.
Tipo
Descripción
r
Lectura. El archivo debe existir.
w
Escribe un nuevo archivo. Si ya existe un archivo con el mismo nombre, su contenido se perderá.
a
Escribe hasta el final del archivo. Se ignoran las operaciones de posicionamiento (fseek, fsetpos, frewind). El archivo se crea si no existía.
r+
Lectura y actualización. Puedes leer y escribir. El archivo debe existir.
w+
Grabación y actualización. Se crea un nuevo archivo. Si ya existe un archivo con el mismo nombre, su contenido se perderá. Puedes escribir y leer.
un+
Finalizar publicación y actualizar. Las operaciones de posicionamiento son de solo lectura y se ignoran para las escrituras. Si el archivo no existía se creará uno nuevo.
fscanf(archivo, "%127s", búfer);Error al abrir el archivo
Almacenamiento en búfer de datos
Si tiene éxito, la función devuelve 0. feof
Ejemplos
Lápiz
bolígrafo lápiz
puerta puerta
ventana de ventanas
silla silla
sillón
NOTA: EOF es de tipo int, por lo que necesita usar int para leer los caracteres. Además, el valor de EOF no está definido por la norma.
tipo: puntero a una cadena de caracteres que define cómo se accede al archivo:
int principal()
... // acciones requeridas sobre los datos
Escribir un símbolo en un archivo:
fprintf(flujo, "Formato de salida", argumentos);
Ejemplo
Ingrese el número y guárdelo en el archivo s1.txt. Lea el número del archivo s1.txt, increméntelo en 3 y guárdelo en el archivo s2.txt.Estructura de archivos FAT32
El tamaño mínimo de archivo requerido en el disco corresponde a 1 clúster.
Trabajar con archivos en lenguaje C
nombre: nombre del archivo a abrir (incluida la ruta),
tipo es un puntero a una cadena de caracteres que define cómo se accede al archivo:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int principal() (
ARCHIVO *fp;
nombre de char = "mi.txt";
si ((fp = fopen(nombre, "r")) == NULL)
{
imprimirf( "Fallo al abrir el archivo");
getchar();
devolver 0;
}
// logró abrir el archivo
... // acciones requeridas sobre los datos
cerrar(fp);
getchar();
devolver 0;
}
El argumento de la función es un puntero a una secuencia de tipo ARCHIVO. La función devuelve el código del carácter leído. Si se llega al final del archivo o se produce un error, se devuelve la constante EOF.
