Notas de operación relacionadas con archivos de lenguaje C

El archivo es una forma de guardar en el disco duro.

Archivo = atributo de archivo + contenido de archivo El
atributo de archivo también son datos (como fecha de modificación, tamaño, tipo)

El conocimiento de las cosas se basa generalmente en atributos.

El valor de la ruta del archivo: posicionamiento (fácil de encontrar)

Nombre de archivo: determina el archivo especificado en una ruta determinada

Nombre de archivo = tronco de archivo + sufijo de archivo

Las operaciones con archivos generalmente incluyen dos partes: operaciones con contenido y operaciones con atributos.

En el diseño de programas, en términos generales, hay dos tipos de archivos: archivos de programa, archivos de datos. Archivos de
programa: incluidos los archivos de origen (archivos con sufijo .c), archivos de destino (archivos .obj para Windows, archivos .o para Linux), programas ejecutables (Windows es .exe).
Archivo de datos: el contenido del archivo no son necesariamente datos, sino los datos leídos y escritos cuando el programa se está ejecutando, como un archivo que necesita leer datos del programa para ejecutarse o un archivo que genera contenido.

Tipo de archivo: según la organización de los datos, los archivos de datos se denominan archivos binarios y archivos de texto .
Archivo binario: los datos se almacenan en la memoria en forma binaria y se almacenan en el archivo intactos sin conversión.
Archivo de texto: un archivo almacenado en forma de caracteres ASC II.

int main()
{
	int a = 10000;
	FILE *fp = fopen("test.txt", "wb");
	if (fp == NULL)
	{
		return 1;
	}
	fwrite(&a, 4, 1, fp);
	fclose(fp);
	return 0;
}

Escriba a en el archivo en forma binaria y abra el archivo como caracteres confusos.

Si desea almacenar un archivo de texto, simplemente defina una variable de carácter.

int main()
{
	int a = 10000;
	FILE *fp = fopen("test.txt", "wb");
	if (fp == NULL)
	{
		return 1;
	}
	const char *str = "10000";
	fwrite(str, 4, 1, fp);
	fclose(fp);
	return 0;
}

Abra el archivo de prueba:

 
 
 
Búfer de archivo:

int main()
{
	printf("Hello world!");
	Sleep(3);
	return 0;
}

En la situación actual: el código se ejecuta de arriba a abajo, independientemente de si se lleva o no “\n”, printf se ejecuta primero.
En el sistema operativo Linux, podemos ver que la salida no se imprimirá inmediatamente, sino que se detendrá durante 3 segundos y la imprimirá después de que finalice el programa.

¿Por qué está pasando esto?
Esto se debe a que hay un búfer cuando el programa se está ejecutando. Cuando se envían al disco duro o la pantalla, los datos se almacenan primero en el búfer. Si hay un método de actualización, se actualizará inmediatamente. De lo contrario, se actualizará después de que el búfer esté lleno, o Cuando el programa finalice, se actualizará automáticamente o se actualizará activamente.

En este ejemplo, printf escribe primero en el búfer y, cuando sea apropiado (\ n, actualización activa, salida del programa) en la pantalla.

“\n”Al imprimir en la pantalla, la estrategia de actualización adoptada es la actualización de línea. Cuando no hay '\ n', no hay actualización, los datos están en el búfer y se actualizará después de la suspensión.

 
Cuando se inicia el programa C, se abren tres archivos de forma predeterminada: entrada estándar, salida estándar y error estándar.
Los dispositivos de hardware correspondientes son: teclado, monitor y monitor.
Los ARCHIVOS correspondientes * se llaman: stdin, stdout, sdterr

Puede tomar una estrategia de actualización activa. fflush (stdout), se puede actualizar.

En circunstancias normales, puede transmitir directamente los datos a la pantalla o poner los datos en el búfer y luego transmitir los datos a la pantalla.

Pero esta operación rara vez se realiza. Generalmente, los datos se colocan primero en el búfer y printf coloca los datos en el búfer. La operación entre memoria -> memoria es muy rápida y memoria -> memoria externa es muy lenta.

¿Qué es un búfer?
Es un área de memoria.

¿Por qué debería haber un búfer? (¿El valor del búfer?)
Mejorar la eficiencia del programa.

por ejemplo:

Quieres enviar cosas a tus amigos que están lejos y tú las envías personalmente a tus amigos. Requiere tiempo y dinero en el camino, lo que genera mucho desperdicio.
En este momento, entregas los artículos a la empresa de mensajería por una tarifa determinada y dejas que la empresa de mensajería te entregue los artículos, y puedes hacer tus propias cosas, solo espera a que lleguen los artículos. -por huevo hermano

En este ejemplo, cosas (Hola palabra), usted (printf), empresa de mensajería (búfer). Si le da algo a la empresa de mensajería, es equivalente a que el programa ponga Hello world en el búfer, y el programa puede continuar ejecutándose, si hay una actualización, actualice. Y también puede hacer sus propias cosas para mejorar la eficiencia.

 
Tres métodos de almacenamiento en búfer:

1. Sin búfer: sin búfer
2. Almacenamiento en búfer de línea: el tamaño del búfer es solo una línea y se actualizará cuando esté lleno.
3. Búfer lleno: actualice el búfer cuando esté lleno (disco duro)

 
 
Puntero de archivo : cada archivo abierto tiene un área de información de archivo correspondiente en la memoria, que se utiliza para almacenar la información relacionada con el archivo (nombre del archivo, ubicación del archivo, etc.). Esta información se almacena en una variable de estructura cuya declaración es FILE .

Defina un ARCHIVO *, haga que el puntero apunte al área de información de un archivo y luego opere el archivo a través del puntero.

Apertura de archivo:

ARCHIVO * fopen (const char * nombre de archivo, const char * modo)

El nombre del archivo abierto y el método de apertura.
Después de abrir, es necesario juzgar si el archivo se abrió correctamente; de ​​lo contrario, no se sabe si el archivo se abrió correctamente.

Cierre del expediente:

int fclose (ARCHIVO * flujo);

Una vez completada la operación del archivo, el archivo debe cerrarse.

Método de apertura de archivos:

lectura y escritura secuencial de archivos:

1. fgetc : int fgetc ( FILE * stream );función de entrada de caracteres, lee todos los caracteres del archivo secuencialmente. -1 se devuelve cuando se lee el archivo. Si el archivo se lee incorrectamente, se devolverá -1, pero se establecerá un error (ferror)
2. fputc : int fputc ( int character, FILE * stream );función de salida de caracteres, escribir caracteres en el archivo secuencialmente, escribir correctamente, devolver el carácter, escribir error, devolver EOF y establecer error (ferror)
3. fgets : char * fgets ( char * str, int num, FILE * stream );función de entrada de línea de texto, leer num caracteres del archivo, en la cadena, la capacidad de la cadena debe ser lo suficientemente grande. La cadena se devuelve correctamente.
4. fputs :, int fputs ( const char * str, FILE * stream );función de salida de línea de texto, escribe todas las cadenas en el archivo. Devuelve un valor no negativo correctamente.
5. fscanf :, int fscanf ( FILE * stream, const char * format, ... );formatee la función de entrada, lea los datos en el archivo en la variable correspondiente, necesite explicar el tipo de datos específico.
6. fprintf :, int fprintf ( FILE * stream, const char * format, ... );formatee la función de salida, escriba los datos en el archivo correspondiente, preste atención al tipo de datos. Si tiene éxito, devuelva la longitud de los datos escritos
7. fread : size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );función de entrada binaria, leer el archivo en los datos en modo binario, el tamaño es el número de bytes leídos, el recuento es la cantidad de bytes leídos. La lectura es correcta, devuelve el valor de la cuenta.
8. fwrite : size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );función de salida binaria, escribe datos en el archivo en forma binaria. La escritura es exitosa y se devuelve el valor de recuento.

 
 
Lectura y escritura aleatoria de archivos:

1. fseek : int fseek ( FILE * stream, long int offset, int origin );ubica el puntero del archivo de acuerdo con la posición y el desplazamiento del puntero del archivo.
   P.ej:

int main()
{
	FILE *fp = fopen("test.txt", "wb");
	char str[15] = "i like you";
	fwrite(str, 5, 2, fp);
	int a = fseek(fp,2,SEEK_SET);
	fputs("love you", fp);
	printf("%s\n", strerror(errno));
	printf("%s", str);
	printf("%d", a);
	return 0;
}

Cambie la posición del puntero del archivo actual y modifique los siguientes datos.
SEEK_SET Inicio del archivo
SEEK_END Fin del archivo SEEK_CUR
Posición actual

2. ftell : long int ftell ( FILE * stream );Devuelve el desplazamiento del puntero del archivo con respecto a la posición inicial.
   P.ej:

	FILE *fp = fopen("test.txt", "rb");
	if (fp == NULL)
	{
		return 1;
	}
	long size;
	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	fseek(fp, 0, SEEK_SET);
	printf("%d\n", size);

Use la función fseek para hacer que el puntero del archivo apunte al final y luego use la función ftell para encontrar el desplazamiento entre los dos. Finalmente, apunte el puntero del archivo a la posición inicial.

3. rebobinar :, void rewind ( FILE * stream );deje que el puntero del archivo apunte al principio del archivo.
Al igual que en el ejemplo anterior, utilícelo directamente.

 
 
 
Esta sección puede dar un ejemplo práctico, podemos copiar un archivo y usar la función anterior.
Únase a nosotros para copiar una imagen, lo que se puede lograr abriendo primero el archivo de muestra, luego abriendo el archivo que se va a copiar, buscando el número de bytes en el archivo de muestra y luego copiándolo.

int main()
{
	FILE *sample = fopen("sample.jpg", "rb");
	if (sample == NULL)
	{
		return 1;
	}
	FILE *copysample = fopen("copysample.jpg", "wb");
	if (copysample == NULL)
	{
		return 2;
	}
	fseek(sample, 0, SEEK_END);
	long size = ftell(sample);
	rewind(sample);
	char *temp = (char *)malloc(size);
	if (temp == NULL)
	{
		return 3;
	}
	fread(temp, size, 1, sample);
	fwrite(temp, size, 1, copysample);
	fclose(sample);
	fclose(copysample);
	free(temp);
	return 0;
}

Archivos copiados:

Estas tres funciones operan en atributos de archivo.

 
 
 
 
Sentencia de fin de expediente:

En el proceso de lectura del archivo, feofel valor de retorno de la función no se puede usar directamente para determinar si el archivo terminó. Más bien, se utiliza cuando finaliza la lectura del archivo para determinar si la lectura falla o si se encuentra el final del archivo.

1. Si la lectura del archivo de texto ha terminado, juzgue si el valor de retorno es EOF (fgetc) o NULL (fgets)

fgetc juzga si es EOF
fgets juzga si es NULL

2. Juicio del final de la lectura del archivo binario y juzgue si el valor de retorno es menor que el número real a leer.

fread determina si el valor de retorno es menor que el número real que se leerá

P.ej:

size_t ret=0
while ((ret = fread(temp, sizeof(temp), 1, fp)) >= 1)

 
 

 

 
Resumen: En esta área, es principalmente necesario realizar operaciones competentes en funciones, lectura y escritura aleatoria de archivos, usar más, juicio final de archivo, distinguir archivos binarios y archivos de texto, sus juicios finales son diferentes y profundizar el almacenamiento en búfer. Comprensión del distrito.