Linux: Operaciones básicas relacionadas con IO de archivos de lenguaje C de revisión de IO

1. Interfaz de archivo de operación en lenguaje C

(1) función fopen

函数原型：
FILE *fopen(const char *path,const char *mode);
参数解释：
path:待打开的文件（文件路径 + 文件名称）
mode:以何种方式打开
返回值：打开文件成功返回文件流指针，打开失败返回NULL

Método abierto:

Método abierto	Explicación
r	Abrir en modo de solo lectura, cuando el archivo no existe, no se abrirá
r +	Abrir en modo lectura-escritura, cuando el archivo no existe, no se abrirá
w	Abrir en modo de solo escritura. Si el archivo no existe, se creará el archivo, si el archivo existe, el archivo se truncará (vacío)
w +	Abra el archivo en modo lectura-escritura, si el archivo no existe, cree el archivo; si el archivo existe, el archivo será truncado (vacío)
a	Abrir en modo anexar, solo admite escritura, si el archivo no existe, se creará el archivo; el puntero de flujo de archivo actual apunta al final del archivo
a +	Abrir en modo anexar, admite lectura y escritura, si el archivo no existe, cree el archivo, el puntero de la secuencia del archivo actual apunta al final del archivo

(2) función fwrite

函数原型：
size_t fwrite(const void *ptr,size_t size,size_t nmemb,FILE *stream);
参数解释：
ptr:要往文件中写的内容
size: 写入块的大小，单位是字节
nmemb:块的个数，单位是个
stream:文件流指针
返回值：返回写入成功时块的个数（不是写入成功字节的数量）

Nota : Generalmente, cuando se usa en el programa, el tamaño se establece en 1, luego nmmbj representa el número de bytes escritos

(3) función fread

函数原型：
size_t fread(void *ptr,size_t size,size_t nmemb,FILE *stream);
参数解释：
ptr:要将读到的内容保存到哪里
size: 每次读块的大小
nmemb: 块的个数
stream:文件流指针
返回值：成功读到的块的个数

(4) función fseek

函数原型：
int fseek(FILE *stream, long offset,int whence);
stream:文件流指针
offset:偏移量
whence:
	SEEK_SET:文件流指针偏移到文件头部
	SEEK_CUR:文件流指针偏移到当前位置
	SEEK_END:文件流指针指向文件末尾位置

(5) función fclose

函数原型：
int fclose(FILE *fp);
作用：关闭文件流指针

Código:

#include <stdio.h>
#include <string.h>

int main()
{
    
    
    FILE* fp = fopen("./linux", "r+");
    if(!fp)
    {
    
    
        perror("fopen");
        return -1;
    }


    char buf[1024] = {
    
    0};
    strcpy(buf, "linux-57");
    ssize_t w_ret = fwrite(buf, 1, 9, fp);
    printf("w_ret:%d\n", w_ret);
    
    fseek(fp, 0, SEEK_SET);

    memset(buf, '\0', sizeof(buf));
    ssize_t r_ret  = fread(buf, 1, sizeof(buf) - 1, fp);
    printf("r_ret:%d, ---  %s\n", r_ret, buf);

    printf("open success\n");
    return 0;
}

Las funciones anteriores son todas funciones de biblioteca.Cuando la biblioteca C proporciona funciones para que los programadores las llamen, compartiré con ustedes las funciones proporcionadas por el kernel del sistema operativo para los programadores.

2. Interfaz de archivo de operación de la función de llamada al sistema

(1) función abierta

函数原型：
int open(const char *pathname, int flags, mod_t mode);
参数解释：
pathname:要打开的文件名称（路径+名称）
flags: 以何种方式打开
mode: 权限
返回值：打开成功，返回大于等于0的数字，是文件描述符，打开失败返回-1

Los parámetros que se pasan en las banderas son definiciones de macros, que se dividen en dos tipos: macros
requeridas y macros opcionales: macros requeridas:

nombre	Explicación
O_RDONLY	Solo lectura
O_WRONLY	Escribir solamente
O_RDWR	Método de lectura y escritura

Macro opcional:

nombre	Explicación
O_APPEND	añadir
O_TRUNC	Truncado
O_CREAT	Crear si el archivo no existe

Cuando lo use, use una combinación de macros necesarias y macros opcionales, y use OR bit a bit entre las macros necesarias y las macros opcionales.
P.ej:

O_RDWR | O_CREAT

(2) función de lectura

函数原型：
ssize_t read(int fd,  void *buf,size_t count);
参数解释：
fd:文件描述符，open的返回值
buf:要将读到的内容放到那里去
count: 最大可以读多少个，单位字节
返回值: 返回读到的字节数量

(3) función de escritura

函数原型：
ssize_t read(int fd,  const void *buf,size_t count);
参数解释：
fd:文件描述符，open的返回值
buf:往文件中写的内容
count: 写的内容的大小
返回值: 写成功的字节数量

(4) función lseek

函数原型：
off_t lseek(int fd,  off_t offset,int whence);
参数解释：
fd:文件描述符，open的返回值
offset:偏移量
whence: 
	SEEK_SET
	SEEK_CUR
	SEEK_END

（5） cerrar

函数原型：
int close(int fd);
作用：关闭文件描述符

Código:

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>


int main()
{
    
    

    close(0);
    int fd = open("./linux", O_RDWR | O_CREAT, 0664);
    if(fd < 0)
    {
    
    
        perror("open");
        return -1;
    }
    printf("%d\n", O_RDWR | O_CREAT);
    printf("fd : %d\n", fd);

    while(1)
    {
    
    
        sleep(1);
    }

    return 0;
}

Descriptor de archivo

Concepto: Un descriptor de archivo es en realidad un pequeño entero que comienza desde 0. Cuando abrimos un archivo, el sistema operativo debe crear una estructura de datos correspondiente en la memoria para describir el archivo de destino. Entonces hay una estructura de archivos. Y abrir ejecuta llamadas al sistema, por lo que el proceso debe estar asociado con el archivo. Cada proceso tiene un puntero * files, que apunta a una tabla files_struct. La parte más importante de la tabla es una matriz de punteros. Cada elemento es un puntero a un archivo abierto. Entonces, en esencia, el descriptor de archivo es el subíndice de la matriz, por lo que siempre que tenga el descriptor de archivo, puede encontrar el archivo correspondiente.

Reglas de asignación de descriptores de archivos

Primero, veamos el resultado del siguiente código

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
    
    
 int fd = open("myfile", O_RDONLY);
 if(fd < 0){
    
    
 perror("open");
 return 1;
 }
 printf("fd: %d\n", fd);
 close(fd);
 return 0;
}

Resultado de la operación: el

resultado es fd: 3

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
    
    
 close(0);
 //close(2);
 int fd = open("myfile", O_RDONLY);
 if(fd < 0){
    
    
 perror("open");
 return 1;
 }
 printf("fd: %d\n", fd);
 close(fd);
 return 0;
}

Resultado de la operación:

desactive 2 o 0 y encuentre que el resultado es fd: 0.
La regla de asignación para descriptores de archivo es: en la matriz file_struct, busque el subíndice más pequeño que no se usa actualmente como un nuevo descriptor de archivo.

3. Redirigir

Si apagamos 1, veremos este fenómeno

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    
    
 close(1);
 int fd = open("myfile", O_WRONLY|O_CREAT, 00644);
 if(fd < 0){
    
    
 perror("open");
 return 1;
 }
 printf("fd: %d\n", fd);
 fflush(stdout);
 
 close(fd);
 exit(0);
}

Resultado de la operación:

En este momento, encontramos que el contenido que debería haberse enviado a la pantalla se envió al archivo myfile, donde fd = 1. Este fenómeno se denomina redirección de salida. Las redirecciones comunes son:>, >>, <La
esencia de la redirección:
## dup2function

函数原型：
#include <unistd.h>
int dup(int oldfd, int newfd);

ejemplo:

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main() {
    
    
 int fd = open("./log", O_CREAT | O_RDWR);
 if (fd < 0) {
    
    
 perror("open");
 return 1;
 }
 close(1);
 dup2(fd, 1);
 for (;;) {
    
    
 char buf[1024] = {
    
    0};
 ssize_t read_size = read(0, buf, sizeof(buf) - 1);
 if (read_size < 0) {
    
    
 perror("read");
 break;
 }
 printf("%s", buf);
 fflush(stdout);
 }
 return 0;
}