Salida de datos del archivo c. Abriendo un archivo

– comparación para identificar igualdad o desigualdad.

El propósito práctico de una enumeración es definir un conjunto de constantes simbólicas distintas de tipo entero.

Un ejemplo de uso de variables enumeradas:

mes=1, tu, we, th, fr, sa, do ) días;

puts(“Ingrese el día de la semana (del 1 al 7):”); scanf(“%d”, &t_día);

w_day = do; inicio = mes;

fin = w_day -t_day;

printf(“\nEl lunes es el %d día de la semana, \ahora es el %d día.\n\

Hasta el final de la semana %d días (días). ”, inicio, t_day, fin);

Resultado del programa: Introduzca el día de la semana (del 1 al 7): 2

El lunes es el primer día de la semana, ahora es el segundo día. Quedan 5 días (días) hasta el final de la semana.

18. Archivos en lenguaje C

Un archivo es un conjunto de datos ubicados en un medio externo y considerados durante el procesamiento como un todo. Los archivos contienen datos destinados al almacenamiento a largo plazo.

Hay dos tipos de archivos: de texto y binarios. Los archivos de texto son una secuencia de caracteres ASCII y se pueden ver y editar con cualquier editor de texto.

Los archivos binarios (binarios) son una secuencia de datos cuya estructura está determinada por el software.

El lenguaje C tiene un gran conjunto de funciones para trabajar con archivos, la mayoría de las cuales se encuentran en las bibliotecas stdio.h e io.h.

18.1. Abriendo un archivo

A cada archivo se le asigna un nombre lógico interno, que se utiliza posteriormente al acceder a él. El nombre lógico (identificador de archivo) es

puntero al archivo, es decir a un área de memoria que contiene toda la información necesaria sobre el archivo. El formato de declaración del puntero del archivo es el siguiente:

	ARCHIVO * puntero al archivo;
ARCHIVO: identificador de tipo de estructura descrito en la biblioteca estándar
stdio.h y que contiene la siguiente información:
escriba estructura (
	– el número de bytes no leídos que quedan en la memoria intermedia;
	el tamaño habitual del búfer es de 512 bytes; tan pronto como el nivel = 0,
	el siguiente bloque de datos se lee en el búfer desde el archivo;
	– indicador de estado del archivo – leer, escribir, agregar;
	– descriptor de archivo, es decir número que define su no-
retención de caracteres sin firmar;	– carácter no transmitido, es decir carácter ungetc;
	– tamaño de la memoria intermedia intermedia interna;
buffer de caracteres sin firmar;	– valor del puntero para el acceso dentro del buffer, es decir
	especifica el comienzo del búfer, el comienzo de la línea o el valor actual
	El valor del puntero dentro del buffer dependiendo del modo.
	almacenamiento en búfer;
carácter sin firmar *curp;	– valor actual del puntero de acceso al interior del
	fera, es decir especifica la posición actual en el buffer de intercambio
	adelante con el programa;
istemp sin firmar;	– indicador de archivo temporal;
	– marcar cuando se trabaja con un archivo;
) ARCHIVO;

Antes de comenzar a trabajar con el archivo, es decir. Para poder leer o escribir información en un archivo, debe estar abierto para acceder. Para ello se suele utilizar la función

ARCHIVO* fopen(char* nombre_archivo, modo char*);

toma una representación externa: el nombre físico de un archivo en un medio (disquete, disco duro) y lo relaciona con un nombre lógico.

Nombre físico, es decir el nombre del archivo y la ruta al mismo se especifican en el primer parámetro

– una línea, por ejemplo, “a:Mas_dat.dat” – un archivo llamado Mas_dat.dat ubicado en un disquete, “d:\\work\\Sved.txt” – un archivo llamado Sved.txt ubicado en el disco duro unidad en el directorio de trabajo.

¡Atención! La barra invertida (\), como carácter especial, se escribe dos veces en una línea.

Tras una apertura exitosa, la función fopen devuelve un puntero al archivo (en lo sucesivo denominado puntero de archivo). En caso de error, se devuelve NULL. Esta situación suele ocurrir cuando la ruta al archivo que se va a abrir se especifica incorrectamente. Por ejemplo, si en la clase de visualización de nuestra universidad especificas una ruta que está prohibida para escribir (normalmente se permite d:\work\).

El segundo parámetro es una línea que especifica el modo de acceso al archivo:

w – el archivo se abre para escritura; si no existe ningún archivo con el nombre indicado, se creará; si dicho archivo existe, la información anterior se destruye antes de abrirlo;

r – el archivo se abre para solo lectura; si no existe dicho archivo, se produce un error;

a – se abre el archivo para agregar nueva información al final;

r+ – el archivo se abre para editar datos – es posible escribir y leer información;

w+ – lo mismo que para r+;

a+ – lo mismo que para a, sólo que se puede escribir en cualquier parte del archivo; la lectura de archivos también está disponible;

t – el archivo se abre en modo texto; b – el archivo se abre en modo binario.

El modo texto se diferencia del modo binario en que cuando un archivo se abre como texto, el par de caracteres "avance de línea", "retorno de carro" se reemplaza por un solo carácter: "avance de línea" para todas las funciones para escribir datos en el archivo. , y para todas las funciones de salida, el carácter “salto de línea” " ahora se reemplaza por dos caracteres: "salto de línea", "retorno de carro".

De forma predeterminada, el archivo se abre en modo texto. Ejemplo: ARCHIVO *f; – se declara un puntero al fichero f;

f = fopen("d:\\trabajo\\Dat_sp.cpp", "w"); – se abre para escritura un archivo con el nombre lógico f, que tiene el nombre físico Dat_sp.cpp, ubicado en la unidad d, en el directorio de trabajo; o más brevemente

ARCHIVO *f = fopen("d:\\trabajo\\Dat_sp.cpp", "w");

18.2. Cerrando un archivo

Después de trabajar con un archivo, se debe cerrar el acceso a él. Esto se hace mediante la función int fclose (puntero de archivo). Por ejemplo, del ejemplo anterior, el archivo se cierra así: fclose (f);

Para cerrar varios archivos, se introduce una función declarada de la siguiente manera: void fcloseall (void);

Si necesita cambiar el modo de acceso a un archivo, primero debe cerrar el archivo y luego abrirlo nuevamente, pero con diferentes derechos de acceso. Para hacer esto, use la función estándar:

ARCHIVO* freopen (char*nombre_archivo, char *modo, ARCHIVO *puntero_archivo);

Esta función primero cierra el archivo declarado. puntero_archivo(como lo hace la función fopen), y luego abre el archivo con el nombre de archivo y los permisos "modo".

El lenguaje C tiene la capacidad de trabajar con archivos temporales que sólo se necesitan mientras se ejecuta el programa. En este caso se utiliza la función

ARCHIVO* tmpfile (nulo);

que crea un archivo temporal en el disco con derechos de acceso "w+b" después de que se completa el programa o después de que se cierra el archivo temporal, se elimina automáticamente;

18.3. Escribir – leer información

Todas las acciones para leer y escribir datos en un archivo se pueden dividir en tres grupos: operaciones de entrada y salida carácter por carácter; operaciones de E/S línea por línea; bloquear operaciones de E/S.

Veamos las funciones principales utilizadas en cada uno de estos tres grupos de operaciones.

E/S carácter por carácter

En las funciones de E/S carácter por carácter, se recibe un carácter de un archivo o se envía un carácter a un archivo:

E/S de fila

Las funciones de E/S de línea se transfieren desde un archivo o a

Bloquear E/S

Las funciones de E/S de bloque operan en bloques completos

información:
int fread (void*p, intsize,	– lee n bloques de tamaño de bytes cada uno del archivo
int n, ARCHIVO *f)	la f a un área de memoria con el puntero p (obligatorio
int fwrite (void*p, intsize,	asignar memoria por adelantado para el bloque a leer);
	– escribe n bloques de tamaño bytes cada uno desde el
int n, ARCHIVO *f)	área de memoria con puntero p al archivo f.

La E/S formateada se produce mediante funciones.

Esta sección analizará dos formas de trabajar con archivos y la clase CFileDialog estándar de MFC.

1. Trabajar con archivos en C (también funciona en C++).

#incluir
#incluir

Vacío principal (nulo)
{
ARCHIVO *archivo;
char* nombre_archivo = "archivo.txt";
char load_string = "ninguno";

Archivo = fopen(nombre_archivo, "w");

Fputs("cadena", archivo);

Archivo = fopen(nombre_archivo, "r");
si(archivo!= 0)
{
fgets(load_string, 50, archivo);
corte)
demás
{
corte)
fclose(archivo);
) Las descripciones de funciones para trabajar con archivos se encuentran en la biblioteca. stdio.h
Primero necesitas crear un puntero a una variable de tipo ARCHIVO ( ARCHIVO* archivo;).
La apertura de un archivo se realiza llamando a la función fopen ( archivo = fopen(nombre_archivo, "w");)
El primer parámetro de esta función es el nombre del archivo, el segundo especifica en qué modo se debe abrir el archivo. "w"- abierto para grabación, "r"- abierto para lectura, "a"- adición de archivos (estos son los modos más utilizados, aunque existen otros). La escritura y lectura de datos de un archivo se realiza mediante las siguientes funciones: fputc, fputs, fgetc, fgets, fprintf, fscanf(para obtener una descripción de estas funciones, consulte stdio.h).
El cierre de un archivo se realiza llamando a la función fclose ( fclose(archivo);).

Trabajar con archivos usando MFC (clases CFile, CStdioFile, ...) y la clase MFC estándar CFileDialog.

La biblioteca MFC incluye varias clases para trabajar con archivos. Las clases que se analizan a continuación heredan de la clase base.

Archivo CF.

Archivo de clase CF

Archivo CFDiseñado para trabajar con archivos. Hace que los archivos sean más fáciles de usar al representar un archivo como un objeto que se puede crear, leer, escribir, etc.

Para acceder a un archivo, primero necesita crear un objeto de la clase CFile. El constructor de clases le permite abrir un archivo inmediatamente después de crear dicho objeto. Pero puedes abrir el archivo más tarde usando el método

Abierto.

Abrir y crear archivos

Después de crear el objeto de clase. Archivo CFpuedes abrir un archivo llamando al métodoAbierto. El método debe especificar la ruta al archivo a abrir y el modo de uso. Prototipo del métodoAbiertotiene la siguiente forma:

Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);

Como parámetro lpszFileName, debe especificar el nombre del archivo que se abrirá. Puede especificar solo el nombre del archivo o el nombre completo del archivo que incluya la ruta completa al mismo.

El segundo parámetro, nOpenFlags, especifica la acción que realiza el método Open en el archivo, así como los atributos del archivo. A continuación se muestran algunos valores posibles para el parámetro nOpenFlags:

• CFile::modeCreate: crea un nuevo archivo. Si el archivo especificado existe, su contenido se borra y la longitud del archivo se establece en cero.
• CFile::modeNoTruncate: este archivo está diseñado para usarse junto con el archivo CFile::modeCreate. Si se crea un archivo existente, su contenido no se eliminará.

Archivo CF::modoRea d: el archivo se abre en modo de solo lectura.

CFile::modeReadWrite: el archivo se abre para escritura y lectura.

CFile::modeWrite: el archivo se abre solo para escritura.

CFile::typeText: utilizado por clases derivadas de la clase CFile, como CStdioFile, para trabajar con archivos en modo texto. El modo de texto convierte la combinación de un carácter de retorno de carro y un carácter de avance de línea.

CFile::Binary: utilizado por clases derivadas de la clase CFile, como CStdioFile, para trabajar con archivos en modo binario.

Parámetro opcional pError, que es un puntero a un objeto de clase CFileException, solo se usa si realizar una operación en el archivo causaría un error. En este caso, se escribirá información adicional en el objeto señalado por pError.

Método AbiertoDevuelve un valor distinto de cero si el archivo está abierto y cero en caso de error. Puede ocurrir un error al abrir un archivo, por ejemplo, si se especifica el método Open para leer un archivo inexistente.

Abrir ID de archivo

La clase CFile incluye un elemento de datos m_hFile de tipo UINT. Almacena el identificador del archivo abierto. Si ya se creó un objeto de la clase CFile, pero el archivo aún no se ha abierto, entonces la constante hFileNull se escribe en la variable m_hFile.

Normalmente, el identificador de archivo abierto no se utiliza directamente. Métodos de clase Archivo CFle permiten realizar casi cualquier operación con archivos y no requieren que especifique un identificador de archivo. Dado que m_hFile es un elemento de clase, la implementación de sus métodos siempre tiene libre acceso a él.

Cerrar archivos

Después de terminar de trabajar con el archivo, debe cerrarse. Clase Archivo CFtiene un método Close especial para esto. Cabe señalar que si se creó un objeto de la clase CFile y se abrió un archivo y luego se elimina el objeto, el archivo asociado se cierra automáticamente mediante un destructor.

Leer y escribir archivos

Hay varios métodos de clase para acceder a archivos. Archivo CF: Leer, LeerHuge, Escribir, WriteHuge, Vaciar. Métodos Leer y LeerEnorme están diseñados para leer datos de un archivo previamente abierto. En sistemas operativos de 32 bits, ambos métodos pueden leer simultáneamente más de 65535 bytes de un archivo. La especificación ReadHuge se considera obsoleta y se conserva únicamente por compatibilidad con sistemas operativos de 16 bits.

Los datos leídos del archivo se escriben en el búfer lpBuf. El parámetro nCount especifica el número de bytes que se leerán del archivo. De hecho, se pueden leer menos bytes del archivo de los solicitados por el parámetro nCount. Esto ocurre si se llega al final del archivo durante la lectura. Los métodos devuelven el número de bytes leídos del archivo.

Los métodos Write y WriteHuge están destinados a escribir en un archivo. En sistemas operativos de 32 bits, ambos métodos pueden escribir simultáneamente más de 65535 bytes en un archivo. El método escribe bytes desde el búfer lpBuf en el archivo abierto nCount. Si se produce un error de escritura, como un disco lleno, los métodos invocan el manejo de excepciones.

Método de descarga

Cuando se utiliza el método Write o WriteHuge para escribir datos en el disco, es posible que permanezcan en un búfer temporal durante algún tiempo. Para asegurarse de que se realicen los cambios necesarios en el archivo en el disco, debe utilizar el método Flush.

Operaciones de archivos

La clase incluye métodos que le permiten realizar diversas operaciones en archivos, como copiar, renombrar, eliminar y cambiar atributos.

Para cambiar el nombre del archivo, la clase CFile incluye un método estático Rebautizar, que realiza las funciones de este comando. El método no se puede utilizar para cambiar el nombre de directorios. Si se produce un error, el método genera una excepción.

Se incluye un método estático en la clase CFile para eliminar archivos. Eliminar, que le permite eliminar el archivo especificado. Este método no le permite eliminar directorios. Si el archivo no se puede eliminar, el método genera una excepción.

Para determinar la fecha y hora de creación del archivo, su longitud y atributos, se utiliza un método estático Obtener el estado. Hay dos variedades de métodos: el primero se define como un método virtual y el segundo se define como un método estático.

Versión virtual del método. Obtener el estadodetermina el estado del archivo abierto asociado con este objeto de clase CFile. Este método solo se llama cuando se crea un objeto de clase CFile y se abre el archivo.

Versión estática del método. Obtener el estadole permite determinar las características de un archivo que no está asociado con un objeto de la clase CFile. Para utilizar este método, no es necesario abrir primero el archivo.

Bloqueo

La clase incluye métodos. Rango de bloqueo Y Rango de desbloqueo, que permiten bloquear uno o más datos de archivos para que otros procesos puedan acceder a ellos. Si una aplicación intenta volver a bloquear datos que previamente fueron bloqueados por esta u otra aplicación, se genera una excepción. El bloqueo es uno de los mecanismos que permite que varias aplicaciones o procesos funcionen en el mismo archivo simultáneamente sin interferir entre sí.

Puedes configurar un bloqueo usando el método Rango de bloqueo. Para eliminar las cerraduras instaladas, debe utilizar el métodoRango de desbloqueo. Si se establecen varios bloqueos en un archivo, cada uno de ellos debe liberarse mediante una llamada a un método independiente.Rango de desbloqueo.

Posicionamiento

Para mover el puntero de posición del archivo actual a una nueva posición, puede utilizar uno de los siguientes métodos de clase Archivo CF - Buscar, buscar para comenzar, buscar para finalizar. A la clase Archivo CFtambién incluye métodos que le permiten configurar y cambiar la longitud del archivo, -ObtenerLongitud, EstablecerLongitud.

Al abrir un archivo, el indicador de posición actual del archivo se encuentra al principio del archivo. Cuando se lee o escribe un dato, el puntero de posición actual se mueve hacia el final del archivo y apunta a los datos que se leerán o escribirán en la siguiente operación de lectura o escritura en el archivo.

Para mover el puntero de posición del archivo actual a cualquier ubicación, puede utilizar el método universal

Buscar. Le permite mover el puntero una cierta cantidad de bytes en relación con la posición inicial, final o actual del puntero.

Para mover el puntero al principio o al final de un archivo, lo más conveniente es utilizar métodos especiales. Método

Buscar para comenzarmueve el puntero al principio del archivo y el métodoBuscar hasta el final- hasta el final.

Pero para determinar la longitud de un archivo abierto, no es necesario mover su puntero. Puedes usar el método

Obtener longitud. Este método también devuelve la longitud del archivo abierto en bytes. MétodoEstablecer longitudle permite cambiar la longitud del archivo abierto. Si este método aumenta el tamaño del archivo, el valor de los últimos bytes no está definido.

La posición actual del puntero del archivo se puede determinar utilizando el método

Obtener posición. Devuelto por métodoObtener posiciónEl valor de 32 bits especifica el desplazamiento del puntero desde el principio del archivo.

Características de un archivo abierto

Para determinar la ubicación de un archivo abierto en el disco, debe llamar al método Obtener ruta de archivo. Este método devuelve un objeto de la clase.Cuerda C, que contiene la ruta completa del archivo, incluido el nombre de la unidad, los directorios, el nombre del archivo y la extensión del archivo.

Si solo necesita determinar el nombre y la extensión de un archivo abierto, puede utilizar el método Obtener nombre de archivo. Devuelve un objeto CString que contiene el nombre del archivo. En el caso de que necesite averiguar solo el nombre de un archivo abierto sin extensión, utilice el métodoObtener título de archivo.

El siguiente método de la clase CFile le permite establecer la ruta del archivo. Este método no crea, copia ni cambia el nombre del archivo; solo completa el elemento de datos correspondiente en el objeto de clase CFile.

Clase C

ArchivoMem

La biblioteca MFC incluye la clase.

CMemFile, heredado de la clase baseArchivo CF. Clase CMemFilerepresenta un archivo ubicado en la RAM. Con objetos de claseCMemFileLo mismo que con los objetos de clase.Archivo CF. La diferencia es que el archivo asociado con el objetoCMemFile, no se encuentra en el disco, sino en la RAM de la computadora. Debido a esto, las operaciones con dicho archivo son mucho más rápidas que con archivos normales.

Trabajar con objetos de clase

CMemFile, puedes usar casi todos los métodos de la clase.Archivo CFlos cuales fueron descritos anteriormente. Puede escribir datos en dicho archivo o leerlo. Además de estos métodos, la clase contieneCMemFilemétodos adicionales incluidos.

Hay dos constructores diferentes para crear objetos de la clase CMemFile. El primer constructor CMemFile tiene solo un parámetro opcional nGrowBytes:

CMemFile(UINT nGrowBytes=1024);

Este constructor crea un archivo vacío en la RAM. Una vez creado, el archivo se abre automáticamente (no es necesario llamar al método Ope

norte).

Cuando comienza la escritura en dicho archivo, se asigna automáticamente un bloque de memoria. Para obtener métodos de clase de memoria

CMemFilellamar a funciones estándarmalloc, realloc Y gratis. Si el bloque de memoria asignado no es suficiente, se aumenta su tamaño. El bloque de memoria del archivo aumenta en partes de bytes nGrowBytes. Después de eliminar un objeto de claseCMemFileLa memoria utilizada se devuelve automáticamente al sistema.

El segundo constructor de la clase CMemFile tiene un prototipo más complejo. Este constructor se utiliza en los casos en que el propio programador asigna memoria para el archivo:

CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);

El parámetro lpBuffer especifica el búfer que se utilizará para el archivo. El tamaño del búfer está determinado por el parámetro nBufferSize.

El parámetro opcional nGrowBytes se utiliza de forma más amplia que en el constructor de primera clase. Si nGrowBytes contiene cero, entonces el archivo generado contendrá los datos del lpBuffer. La longitud de dicho archivo será igual a nBufferSize.

Si nGrowBytes es mayor que cero, entonces se ignora el contenido de lpBuffer. Además, si se escriben más datos en dicho archivo de los que caben en el búfer asignado, su tamaño aumenta automáticamente. El bloque de memoria del archivo aumenta en partes de bytes nGrowBytes.

CMemFilele permite obtener un puntero al área de memoria utilizada por el archivo. A través de este puntero puedes trabajar directamente con el contenido del archivo, sin limitarte a los métodos de clase.Archivo CF. Para obtener un puntero a un búfer de archivo, puede utilizar el método Detach. Antes de hacer esto, es útil determinar la longitud del archivo (y por lo tanto el tamaño del buffer de memoria) llamando al métodoObtener longitud. Despegarcierra el archivo dado y devuelve un puntero al bloque de memoria que está utilizando. Si nuevamente necesita abrir el archivo y asociarle un bloque de RAM, debe llamar al métodoAdjuntar.

Cabe señalar que para administrar la clase de búfer de archivos

CMemFilellama a funciones estándarmalloc, realloc Y gratis. Por lo tanto, para no romper el mecanismo de administración de memoria, las funciones deben crear el búfer lpBuffermalloc o calloc.

Clase CStdioFile

Aquellos que estén acostumbrados a utilizar las funciones de E/S de streaming de la biblioteca estándar C y C++ deberían prestar atención a la clase

Archivo CStdio, heredado de la clase baseArchivo CF. Esta clase le permite realizar E/S almacenadas en búfer en modo texto y binario. Para objetos de claseArchivo CStdioPuede llamar a casi todos los métodos de la clase CFile.Archivo CStdioincluye el elemento de datos m_pStream, que contiene un puntero al archivo abierto. Si un objeto de claseArchivo CStdiocreado, pero el archivo aún no está abierto ni cerrado, entonces m_pStream contiene la constante NULL.Archivo CStdioTiene tres constructores diferentes. El primer constructor de la clase CStdioFile no tiene parámetros. Este constructor sólo crea un objeto de clase, pero no abre ningún archivo. Para abrir un archivo, necesita llamar al métodoAbiertoclase baseArchivo CF.

constructor de segunda clase

Archivo CStdiose puede llamar si el archivo ya está abierto y necesita crear un nuevo objeto de la clase CStdioFile y asociar el archivo abierto con él. Este constructor se puede utilizar si el archivo se abrió con una función estándar.abrir. El parámetro del método debe contener un puntero al archivo obtenido llamando a la función estándar.abrir.

El tercer constructor se puede utilizar si necesita crear un objeto de clase.

Archivo CStdio, abra un nuevo archivo y asócielo con el objeto recién creado.

Para leer y escribir en un archivo de texto, la clase CStdioFile incluye dos métodos nuevos:

Leer cadena Y escribir cadena. El primer método le permite leer una cadena de caracteres de un archivo y el segundo método le permite escribirlo.

Ejemplos de escritura y lectura de un archivo.

Aquí hay fragmentos de código que demuestran el uso de paneles de diálogo de selección de archivos estándar y el procedimiento para leer y escribir en un archivo.

Abrir un archivo y leerlo

CString m_Text; …… // creando un panel de selección de archivos estándar Abrir CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Archivos de texto (*.txt) |*.txt||"); // muestra el panel de selección de archivos estándar Abrir si(DlgOpen.DoModal()==IDOK) ( // crea un objeto y abre el archivo para leer Archivo CStdioFile(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary); // leer cadenas del archivo CString& ref=m_Text; Archivo.ReadString(ref ); // se pasa una referencia a una cadena m_Texto)

Abrir y escribir desde un archivo

CString m_Text; …… // creando un panel de selección de archivos SaveAs estándar CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Archivos de texto (*.txt) |*.txt||"); // muestra el panel de selección de archivos estándar Guardar como si(DlgSaveAs.DoModal()==IDOK) ( // crea un objeto y abre un archivo para escribir Archivo CStdioFile(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary); //escribir en un archivo de cadena Archivo.WriteString((LPCTSTR)m_Text); )

contiene el código de trabajo del programa, diseñado para simplificar como aplicación de consola en MFC. Para que el programa funcione no olvides hacer lo siguiente:

Ejecute el programa - Construir / Reconstruir todo (habrá errores), seleccione Construir / Establecer configuración activa - Win 32 Realise, seleccione el elemento del menú "Proyecto", luego "Configuración...", la pestaña "C/C++", Categoría: Generación de código y en el elemento "Usar biblioteca en tiempo de ejecución", seleccione "Multiproceso". Después de eso, haga Build/Rebuild todo nuevamente y el programa funcionará.

Archivos de texto

Veamos cómo trabajar con un archivo de texto en C usando un ejemplo. Cree un archivo de texto en la unidad C llamado TextFile.txt. Escriba las siguientes líneas en este archivo:

Cadena_1 123 Cadena_11, 456
Cadena_2
Cadena_3

Guarda el archivo.

Y este es el código de un programa en C que abre nuestro archivo y lee líneas del mismo:

/* *Autor: @autor Subbotin B.P..h> #include #define LEN 50 int main(void) ( puts("Operaciones de archivos de texto"); char cArray; ARCHIVO *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Problemas"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile) return EXIT_SUCCESS;

Para abrir un archivo de texto en C, use la función fopen:

ARCHIVO *pTextFile = fopen("C:\\TextFile.txt", "r");

El primer argumento de la función fopen apunta a un archivo y el segundo dice que el archivo está abierto para leerlo.

Leemos las líneas usando la función fgets:

fgets(cArray, LEN, pTextFile);

El primer argumento de la función fgets apunta a una matriz de caracteres en la que se almacenarán las cadenas recibidas, el segundo argumento es el número máximo de caracteres a leer y el tercero es nuestro archivo.

Después de terminar de trabajar con el archivo, debes cerrarlo:

fclose(pTextFile);

Obtenemos:

También aparecen letras rusas en las líneas.

Por cierto, hice este programa en Eclipse. Puedes ver cómo trabajar con C/C++ en Eclipse.

Entonces, abrimos y leímos datos de un archivo de texto.

Ahora aprenderemos cómo crear mediante programación un archivo de texto y escribir datos en él.

/* Autor: @author Subbotin B.P..h> #include int main(void) ( ARCHIVO *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Esto es una cadena"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("Problemas"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine);

Cree un archivo de texto para escribir datos en:

ARCHIVO *pTextFile = fopen("C:\\TextFileW.txt", "w");

si el archivo ya existe, se abrirá y se eliminarán todos los datos que contiene.

El programa escribe la cadena C cString y el número nVal en un archivo de texto. cNewLine es simplemente una nueva línea.

Escribimos datos en un archivo de texto usando la función fprintf:

fprintf(pTextFile, "%s%c", cString, cNewLine);

El primer argumento aquí es nuestro archivo, el segundo es la cadena de formato, el tercero o más es el número de argumentos necesarios para este formato.

Última actualización: 31/10/2015

Clase flujo de archivos representa las capacidades de leer de un archivo y escribir en un archivo. Te permite trabajar tanto con archivos de texto como binarios.

Consideremos sus propiedades y métodos más importantes:

Propiedad de longitud: devuelve la longitud de la secuencia en bytes

Propiedad de posición: devuelve la posición actual en la secuencia

Método de lectura: lee datos de un archivo en una matriz de bytes. Toma tres parámetros: int Read(matriz de bytes, int offset, int count) y devuelve el número de bytes leídos correctamente. Aquí se utilizan los siguientes parámetros:

• matriz: una matriz de bytes donde se colocarán los datos leídos del archivo

  offset representa el desplazamiento en bytes en la matriz en la que se colocarán los bytes leídos

  count: el número máximo de bytes que se leerán. Si hay menos bytes en el archivo, se leerán todos.

Método Búsqueda larga (desplazamiento largo, origen SeekOrigin): establece la posición en la secuencia con un desplazamiento del número de bytes especificado en el parámetro de desplazamiento.

Método de escritura: escribe datos de una matriz de bytes en un archivo. Toma tres parámetros: Escritura (matriz de bytes, desplazamiento int, recuento int)

• matriz: una matriz de bytes desde la cual se escribirán los datos en el archivo

  offset: el desplazamiento en bytes en la matriz desde donde los bytes comienzan a escribirse en la secuencia

  count: número máximo de bytes que se escribirán

FileStream representa el acceso a archivos a nivel de bytes, por lo que, por ejemplo, si necesita leer o escribir una o más líneas en un archivo de texto, entonces la matriz de bytes debe convertirse en cadenas utilizando métodos especiales. Por lo tanto, se utilizan otras clases para trabajar con archivos de texto.

Al mismo tiempo, cuando se trabaja con varios archivos binarios que tienen una determinada estructura, FileStream puede resultar muy útil para extraer determinada información y procesarla.

Veamos un ejemplo de lectura y escritura en un archivo de texto:

Console.WriteLine("Ingrese una línea para escribir en el archivo:"); texto de cadena = Console.ReadLine(); // escribir en un archivo usando (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) ( // convertir la cadena a bytes matriz de bytes = System.Text.Encoding. Predeterminado. GetBytes(text); // escribiendo una matriz de bytes en un archivo fstream.Write(array, 0, array.Length); Console.WriteLine("Texto escrito en un archivo"); fstream = File. OpenRead(@"C:\SomeDir\noname\note.txt")) ( // convierte la cadena en bytes byte array = nuevo byte; // lee los datos fstream.Read(array, 0, array. Longitud); // decodifica bytes en cadena textFromFile = System.Text.Encoding.Default.GetString(array Console.WriteLine("Texto del archivo: (0)", textFromFile ) Console.ReadLine();

Veamos este ejemplo. Tanto la lectura como la escritura utilizan la declaración de uso. Esta declaración no debe confundirse con la directiva de uso, que incluye espacios de nombres al principio del archivo de código. La declaración de uso le permite crear un objeto en un bloque de código, al finalizar el cual se llama al método Dispose de ese objeto y, por lo tanto, el objeto se destruye. En este caso, la variable fstream sirve como tal objeto.

El objeto fstream se crea de dos formas diferentes: a través del constructor y mediante uno de los métodos estáticos de la clase Archivo.

Aquí se pasan dos parámetros al constructor: la ruta del archivo y la enumeración FileMode. Esta enumeración indica el modo de acceso al archivo y puede tomar los siguientes valores:

Agregar: si el archivo existe, el texto se agrega al final del archivo. Si el archivo no existe, se crea. El archivo se abre sólo para escritura.

Crear: se crea un nuevo archivo. Si dicho archivo ya existe, se sobrescribe

CreateNew: Se crea un nuevo archivo. Si dicho archivo ya existe, la aplicación arroja un error

Abrir: abre un archivo. Si el archivo no existe, se lanza una excepción.

OpenOrCreate: si el archivo existe, se abre, si no, se crea uno nuevo

Truncar: si el archivo existe, se sobrescribe. El archivo se abre sólo para escritura.

El método estático OpenRead de la clase File abre un archivo para leer y devuelve un objeto FileStream.

El constructor de la clase FileStream también tiene una serie de sobrecargas que le permiten personalizar con mayor precisión el objeto que se está creando. Todas estas versiones se pueden ver en msdn.

Tanto la escritura como la lectura utilizan el objeto de codificación Encoding.Default del espacio de nombres System.Text. En este caso, utilizamos dos de sus métodos: GetBytes para obtener una matriz de bytes de una cadena y GetString para obtener una cadena de una matriz de bytes.

Como resultado, la cadena que ingresamos se escribe en el archivo. nota.txt. Esencialmente, este es un archivo binario (no un archivo de texto), aunque si escribimos solo una línea en él, podemos ver este archivo en una forma legible por humanos abriéndolo en un editor de texto. Sin embargo, si escribimos bytes aleatorios en él, por ejemplo:

Fstream.WriteByte(13); fstream.WriteByte(103);

Entonces podemos tener problemas para entenderlo. Por lo tanto, se han diseñado clases independientes para trabajar directamente con archivos de texto: StreamReader y StreamWriter.

Acceso aleatorio a archivos

A menudo, los archivos binarios representan una estructura específica. Y, conociendo esta estructura, podemos tomar la información necesaria del archivo o, por el contrario, escribir un determinado conjunto de bytes en un lugar determinado del archivo. Por ejemplo, en los archivos WAV, los datos de audio en sí comienzan en 44 bytes, y hasta 44 bytes hay varios metadatos: el número de canales de audio, la frecuencia de muestreo, etc.

Usando el método Seek(), podemos controlar la posición del cursor de flujo, a partir del cual se lee o escribe el archivo. Este método toma dos parámetros: desplazamiento y posición en el archivo. Una posición en un archivo se describe mediante tres valores:

SeekOrigin.Begin: comienzo del archivo

SeekOrigin.End: fin del archivo

SeekOrigin.Current: posición actual en el archivo

El cursor de la secuencia desde la que comienza la lectura o escritura se desplaza hacia adelante en un desplazamiento relativo a la posición especificada como segundo parámetro. El desplazamiento puede ser negativo, luego el cursor se mueve hacia atrás, si es positivo, luego hacia adelante.

Veamos un ejemplo:

Usando System.IO; usando System.Text; clase Programa ( static void Main(string args) ( string text = "hola mundo"; // escribiendo en un archivo usando (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) ( / / convertir la cadena a bytes input = Encoding.Default.GetBytes(text); // escribir una matriz de bytes en un archivo fstream.Write(input, 0, input.Length Console.WriteLine("Texto escrito en el archivo"); ); mueve el puntero al final del archivo, cinco bytes hasta el final del archivo fstream.Seek(-5, SeekOrigin.End // menos 5 caracteres desde el final de la secuencia // lee cuatro caracteres del archivo); posición actual byte salida = nuevo byte( salida, 0, salida.Longitud); // decodifica los bytes en una cadena textFromFile = Encoding.Default.GetString(salida Console.WriteLine("Texto del archivo: (0)" , textFromFile); en el archivo, la palabra mundo a la palabra casa string replaceText = "house"; fstream.Seek(-5, SeekOrigin.End); // menos 5 caracteres desde el final de la secuencia input = Encoding.Default. GetBytes(reemplazarTexto); , 0, entrada.Longitud); // lee el archivo completo // devuelve el puntero al principio del archivo fstream.Seek(0, SeekOrigin.Begin); salida = nuevo byte; fstream.Read(salida, 0, salida.Longitud); // decodifica los bytes en una cadena textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Texto del archivo: (0)", textFromFile); // hola casa ) Console.Read(); ) )

Salida de consola:

Texto escrito en el archivo Texto del archivo: worl Texto del archivo: hola casa

Llamar a fstream.Seek(-5, SeekOrigin.End) mueve el cursor de secuencia al final de los archivos y retrocede cinco caracteres:

Es decir, después de escribir la línea "hola mundo" en un nuevo archivo, el cursor estará en la posición del carácter "w".

Después de esto, leemos cuatro bytes que comienzan con el carácter "w". En esta codificación, 1 carácter representará 1 byte. Por tanto, leer 4 bytes equivaldrá a leer cuatro caracteres: "world".

Luego, nuevamente, nos movemos hasta el final del archivo, sin llegar al final de cinco caracteres (es decir, nuevamente desde la posición del carácter "w"), y escribimos la cadena "casa". Entonces la cadena "casa" reemplaza la cadena "mundo".

cerrando un hilo

En los ejemplos anteriores, se utiliza una construcción de uso para cerrar una secuencia. Una vez procesados ​​todos los operadores y expresiones del bloque de uso, el objeto FileStream se destruye. Sin embargo, podemos elegir otra forma:

FileStream fstream = nulo; try ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // operaciones con el flujo ) catch(Exception ex) ( ) finalmente ( if (fstream != null) fstream.Close() ; )

Si no utilizamos la construcción de uso, entonces necesitamos llamar explícitamente al método Close(): fstream.Close()

Anteriormente, al ingresar y enviar datos, trabajábamos con flujos estándar: el teclado y el monitor. Ahora veamos cómo el lenguaje C implementa la recepción de datos de archivos y su escritura allí. Antes de poder realizar estas operaciones, debe abrir el archivo y acceder a él.

En el lenguaje de programación C, un puntero a un archivo es de tipo ARCHIVO y su declaración tiene este aspecto:
ARCHIVO *miarchivo;

Por otro lado, la función fopen() abre un archivo en la dirección especificada como primer argumento en modo lectura ("r"), modo escritura ("w") o modo anexar ("a") y devuelve un puntero. al programa. Por lo tanto, el proceso de abrir un archivo y conectarlo al programa se parece a esto:
miarchivo = fopen("hola.txt", "r");

Al leer o escribir datos en un archivo, se accede a él a través de un puntero de archivo (en este caso, miarchivo).

Si por una razón u otra (no hay ningún archivo en la dirección especificada, se deniega el acceso) la función fopen() no puede abrir el archivo, entonces devuelve NULL. En los programas reales, casi siempre manejan un error de apertura de archivo en la rama if, pero omitiremos esto más.

La declaración de la función fopen() está contenida en el archivo de encabezado stdio.h, por lo que debe incluirse. También en stdio.h se declara el tipo de estructura ARCHIVO.

Una vez finalizado el trabajo con un archivo, se acostumbra cerrarlo para liberar el búfer de datos y por otros motivos. Esto es especialmente importante si el programa continúa ejecutándose después de trabajar con el archivo. La interrupción de la conexión entre un archivo externo y un puntero a él desde el programa se realiza mediante la función fclose(). Se le pasa un puntero al archivo como parámetro:
fclose(miarchivo);

Se puede abrir más de un archivo en el programa. En este caso, cada archivo debe estar asociado con su propio puntero de archivo. Sin embargo, si el programa primero trabaja con un archivo y luego lo cierra, entonces el puntero se puede usar para abrir un segundo archivo.

Leer y escribir en un archivo de texto

fscanf()

La función fscanf() tiene un significado similar a la función scanf(), pero a diferencia de ella, proporciona entrada formateada desde un archivo en lugar de entrada estándar. La función fscanf() toma parámetros: puntero de archivo, cadena de formato, direcciones de áreas de memoria para escribir datos:
fscanf(miarchivo, "%s%d", str, &a);

Devuelve el número de datos leídos correctamente o EOF. Los espacios y los caracteres de nueva línea se cuentan como delimitadores de datos.

Digamos que tenemos un archivo que contiene la siguiente descripción de objetos:

Manzanas 10 23,4 plátanos 5 25,0 pan 1 10,3

#incluir main () ( ARCHIVO * archivo; struct food ( nombre char[ 20 ] ; cantidad sin firmar; precio flotante; ); struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt", "r" ) ; while (fscanf (archivo, "%s%u%f", tienda[i].nombre, & (tienda[i].cantidad), & (tienda[i].precio) != EOF) ( printf ( "%s %u %.2f \norte", tienda[i].nombre, tienda[i].cantidad, tienda[i].precio); yo ++; ) )

En este caso, se declaran una estructura y un conjunto de estructuras. Cada línea del archivo corresponde a un elemento de la matriz; un elemento de matriz es una estructura que contiene una cadena y dos campos numéricos. El bucle lee una fila por iteración. Cuando se encuentra el final del archivo, fscanf() devuelve EOF y el ciclo finaliza.

fget()

La función fgets() es similar a la función gets() y realiza entrada línea por línea desde un archivo. Una llamada a fgets() leerá una línea. En este caso, no podrás leer toda la línea, sino sólo una parte desde el principio. Los parámetros de fgets() se ven así:
fgets (matriz_caracteres, número_de_caracteres_leídos, puntero_al_archivo)

Por ejemplo:
fgets(cadena, 50, miarchivo)

Esta llamada a la función leerá del archivo asociado con el puntero myfile una línea completa de texto si su longitud es inferior a 50 caracteres, incluido el carácter "\n", que la función también almacenará en una matriz. El último elemento (50.º) de la matriz str será el carácter "\0" agregado por fgets() . Si la cadena es más larga, la función leerá 49 caracteres y escribirá "\0" al final. En este caso, "\n" no estará contenido en la línea de lectura.

#incluir #define N 80 main () ( ARCHIVO * archivo; char arr[ N] ; archivo = fopen ("fscanf.txt", "r" ); while (fgets (arr, N, archivo) != NULL) printf (" %s", arreglo); printf (" \norte") ; fclose(archivo); )

En este programa, a diferencia del anterior, los datos se leen línea por línea en la matriz arr. Cuando se lee la siguiente línea, la anterior se pierde. La función fgets() devuelve NULL si no puede leer la siguiente línea.

getc() o fgetc()

La función getc() o fgetc() (ambas funcionan) le permite obtener el siguiente carácter de un archivo.

while ((arr[ i] = fgetc (archivo) ) != EOF) ( if (arr[ i] == " \norte") (arr[i] = " \0 " ; printf("%s \norte", arr); yo = 0; ) más i++; )arr[i] = " \0 " ; printf("%s \norte", arr);

El código de ejemplo muestra datos de un archivo en la pantalla.

Escribir en un archivo de texto

Al igual que la entrada, la salida a un archivo puede ser diferente.

• Salida formateada. Función fprintf (file_index, format_string, variables).
• Salida post-por-línea. Función fputs(cadena, file_pointer).
• Salida carácter por carácter. Función fputc() o putc(symbol, file_pointer).

A continuación se muestran ejemplos de código que utilizan tres métodos para enviar datos a un archivo.

Escribir campos de una estructura en cada línea del archivo:

archivo = fopen ("fprintf.txt", "w"); while (scanf ("%s%u%f", tienda[i].nombre, & (tienda[i].cantidad), & (tienda[i].precio))!= EOF) (fprintf (archivo, " %s %u %.2f \norte", tienda[i].nombre, tienda[i].cantidad, tienda[i].precio); yo ++; )

Salida línea por línea a un archivo (fputs(), a diferencia del propio puts(), no coloca “\n” al final de la línea):

while (obtiene (arr) != NULL) ( fputs (arr, archivo); fputs (" \norte", archivo);

)

Ejemplo de salida carácter por carácter:

mientras ((i = getchar ()) != EOF) putc (i, archivo);

Leer y escribir en un archivo binario

Puede trabajar con un archivo no como una secuencia de caracteres, sino como una secuencia de bytes. En principio, no es posible trabajar de otra forma con archivos que no sean de texto. Sin embargo, esto también se puede utilizar para leer y escribir en archivos de texto. La ventaja de este método de acceder a un archivo es la velocidad de lectura y escritura: se puede leer/escribir un bloque importante de información en un solo acceso.

Al abrir un archivo para acceso binario, el segundo parámetro de fopen() es la cadena "rb" o "wb".

El tema de trabajar con archivos binarios es bastante complejo y requiere una lección separada para estudiarlo. Aquí sólo se señalarán las características de las funciones de lectura y escritura en un archivo, que se considera un flujo de bytes.

1. Las funciones fread() y fwrite() toman como parámetros:
2. dirección del área de memoria donde se escriben o leen los datos,
3. el tamaño de un tipo determinado,
4. índice de archivos.

Estas funciones devuelven la cantidad de datos leídos o escritos correctamente. Aquellos. puedes “ordenar” la lectura de 50 elementos de datos, pero recibirás solo 10. No habrá ningún error.

Un ejemplo de uso de las funciones fread() y fwrite():

#incluir #incluir principal () ( ARCHIVO * archivo; char estante1[ 50 ], estante2[ 100 ] ; int n, m; archivo = fopen ("estante1.txt", "rb" ); n= fread (estante1, tamaño de (char), 50, archivo); fclose (archivo); archivo = fopen ("shelf2.txt", "rb"); m= fread (shelf2, sizeof (char), 50, archivo); \0 " ; estante2[m] = " \norte"; estante2[ m+ 1 ] = " \0 " ; archivo = fopen ("tienda.txt", "wb"); fwrite (strcat (estante2, estante1), tamaño de (char), n+ m, archivo); fclose(archivo); )

Aquí se intenta leer 50 caracteres del primer archivo. n almacena el número de caracteres realmente leídos. El valor de n puede ser 50 o menos. Los datos se colocan en una fila. Lo mismo ocurre con el segundo archivo. A continuación, la primera línea se agrega a la segunda y los datos se volcan en el tercer archivo.

resolución de problemas

1. Escriba un programa que solicite al usuario el nombre (dirección) de un archivo de texto, luego lo abra y cuente el número de caracteres y líneas que contiene.
2. Escriba un programa que escriba en un archivo datos recibidos de otro archivo y modificados de alguna manera antes de escribirlos. Cada línea de datos obtenida de un archivo debe encajar en una estructura.