/* Leemos la tercera línea carácter a carácter y la mostramos en la pantalla. */

para (i =0 ;с !=*“” ;i++)
{
si (i>tamañode (c )) romper ;
corte<<с[i];
}

obtener(); \\Esperando a que se presione la tecla Enter
devolver 0;
}
===================

Este material describe un ejemplo de lectura de información carácter por carácter. Como no describí trabajar con variables como carbonizarse, los principiantes pueden experimentar algunos inconvenientes al comprender el código. Simplemente no sabía de qué tipo carbonizarse Tiene algunas peculiaridades y pensé que todo era más sencillo. Por tanto, algunos puntos incomprensibles del programa anterior se pueden leer en el siguiente artículo. trabajando con carbón V C++ para principiantes

De lo contrario, el ejemplo dado de cómo leer líneas de un archivo de texto en C++ debería ser accesible y bastante comprensible. Esta no es la opción de implementación óptima en este momento y me perdí algunos puntos importantes, pero como estamos empezando a aprender el lenguaje C++, esto es suficiente por ahora. Más adelante probablemente llegaré a lo que me perdí, pero ahora necesito percibir sólo lo más necesario.

Si usted y yo entendemos este material, significa que hemos dado un pequeño paso hacia nuestro profesionalismo.

Nota:
romper ;– Este es el comando que sale del bucle. Tenemos si el contador de ciclos. para se vuelve más grande que el tamaño declarado de la variable carbonizarse, luego salimos con fuerza del bucle
!= – Esta es la condición que ponemos. Esta condición se denota por la desigualdad.
si(a!=b)– Se lee como si a no es igual b

fin; – Esto es para mover el cursor a una nueva línea dentro de la consola (hasta donde tengo entendido)
Este comando es similar a "\norte"

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),
tipo: puntero a una cadena de caracteres que define cómo se accede al archivo:

· "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
int principal()

nombre char="mi.txt";

si(fp = fopen(nombre, "r")!=NULL)

// ¿fue posible abrir el archivo?
... // acciones requeridas sobre los datos

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.
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, "Formato de entrada", argumentos);
fprintf(flujo, "Formato de salida", 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.
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.

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");