Abrir archivo para escribir desde. Trabajar con archivos de texto en C

Ú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 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, hay clases separadas diseñadas 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); byte de posición actual 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

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()

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

Guarde el archivo.

Y este es el código de un programa 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 aprendamos 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 contenga.

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.

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 registro 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 primero, 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=";

//ingresa un número

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())

//leer 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 anotar 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 contar 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 aberturas 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 está abriendo, modo es una cadena que determina el modo para 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 cierre 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, un valor distinto de cero si la compensación falló.

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

// emocionante 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);

// emocionante puntero A mínimo elemento

fseek(f, tamaño de (int)+imin*tamaño de (doble), SEEK_SET);

//escribe max en lugar del elemento de archivo mínimo

fwrite(&max, tamaño de(doble), 1, f);

//cerrando el archivo

cerrar(f);

//liberando memoria

borrar [ ]a;

sistema("pausa");