Este artículo describe brevemente las funciones básicas de Linux file io. File IO también se llama llamada al sistema IO. Es un conjunto de interfaces proporcionadas por el sistema operativo para la interacción entre los procesos que se ejecutan en "modo de usuario" y el hardware. El kernel del sistema operativo está reservado para los programas del usuario. Según la estructura del sistema operativo, el sistema Linux se divide de arriba a abajo: proceso de usuario, kernel de Linux y hardware físico. El kernel de Linux incluye dos partes, la interfaz de llamada al sistema y el subsistema del kernel. El kernel de Linux ocupa una posición clave al "conectar el pasado y el futuro", administrar el hardware físico hacia abajo y proporcionar interfaces para el sistema operativo y las aplicaciones hacia arriba. Las interfaces aquí son llamadas al sistema.
A continuación se presentan las funciones generales de apertura, lectura, escritura, búsqueda y cierre de archivos.
abierto
archivo principal
#incluir <sys/stat.h>
#incluir <fcntl.h>función
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
función
para abrir el archivo y obtener el
descriptor
de archivo para operar el archivo Parámetros nombre de ruta: la cadena correspondiente al archivo ruta a abrir
Banderas
de primera dirección O_RDONLY de solo
lectura O_WRONLY de solo escritura
O_RDWR lectura-escrituraSolo se puede especificar una de las tres constantes anteriores (las siguientes constantes están conectadas mediante | (u operación))
El archivo O_CREAT no existe para crear (requiere abrir para pasar el tercer parámetro)
El archivo O_TRUNC existe y está truncado a 0 (borrado a 0)
O_APPEND agregado para abrir
O_ASYNC IO asíncrono
O_NONBLOCK IO sin bloqueo
O_EXCL Detecta si el archivo existe
Valor de retorno
Devuelve con éxito un nuevo descriptor de archivo
Devolución fallida -1
cerca
archivo principal
#incluir <unistd.h>
función
int close(int fd);
función
cierra los
parámetros del descriptor de archivo valor de retorno
del descriptor de archivo éxito retorno 0 fracaso retorno -1
escribir
archivo principal
#incluir <unistd.h>
función
ssize_t write(int fd, const void *buf, size_t count);
Función
Escribe el conteo de bytes de datos que comienzan con buf en el archivo correspondiente al descriptor de archivo
Parámetros
fd: descriptor de archivo
buf: almacena la primera dirección del espacio de datos
conteo: escribe
Valor de retorno del número de bytes ingresados.
Si se realiza correctamente, devuelve el número real de bytes escritos.
Si falla, se devuelve -1.
leer
archivo principal
#incluir <unistd.h>
Función
ssize_t read(int fd, void *buf, size_t count);
Función
Leer el conteo de bytes del descriptor del archivo y colocarlos en el espacio señalado por buf
Parámetros
fd: descriptor de archivo buf: almacenar la primera dirección del conteo
del espacio de datos : El valor de retorno
del número máximo de bytes de datos leídos . Si tiene éxito, devolverá el número real de bytes leídos. Si falla, devolverá -1 y devolverá 0 cuando lea el final del archivo.
Ahora uso las cuatro interfaces de funciones presentadas anteriormente para implementar una copia de un archivo.
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char const *argv[])
{
int fd_src = 0;
int fd_dst = 0;
char tmpbuff[1024] = {0};
ssize_t nret = 0;
fd_src = open("src.jpg",O_RDONLY);//打开文件只读
fd_dst = open("dst.jpg",O_WRONLY | O_TRUNC | O_CREAT,0664);/*打开文件读写、截断为0、如果文件不存在则创建 mode（110 110 100）*/
if(-1 == fd_dst || -1 == fd_src)
{
perror("fail to open");
return -1;
}
while (1)
{
nret = read(fd_src, tmpbuff, sizeof(tmpbuff));//读到多少返回到nret
if(0 >= nret)//如果nret不大于0则说明读到末尾
{
break;
}
write(fd_dst,tmpbuff,nret);//上面nret为多少就写多少
}
close(fd_src);
close(fd_dst);//关闭两文件
return 0;
}
buscar
archivo principal
#incluir <unistd.h>
función
off_t lseek(int fd, off_t offset, int de dónde);
Función
Reubicar
el parámetro
de desplazamiento del descriptor de archivo fd:
desplazamiento del descriptor de archivo: desplazamiento
>0 desplazamiento hacia atrás
<0 desplazamiento hacia adelante
de dónde:
archivo SEEK_SET SEEK_CUR al principio
del archivo en la posición actual
SEEK_END al final del archivo
Valor de retorno
Devuelve con éxito el desplazamiento,
el error devuelve -1
Lo siguiente es utilizar la función lseek para operar en el archivo.
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
int main(void)
{
int fd = 0;
off_t len = 0;
fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0664);
if (-1 == fd)
{
perror("fail to open");
return -1;
}
len = lseek(fd, 10, SEEK_SET);//定位文件开头向后偏移10
printf("偏移量:%ld\n", len);
write(fd, "a", 1);
len = lseek(fd, -5, SEEK_CUR);//定位文件当前向前偏移5
printf("偏移量:%ld\n", len);
write(fd, "b", 1);
len = lseek(fd, 0, SEEK_SET);//定位文件开头无偏移
printf("偏移量:%ld\n", len);
write(fd, "c", 1);
close(fd);
return 0;
}Se puede ver que el desplazamiento de 10 se coloca inicialmente en 10, y después de insertar una A, el desplazamiento es 11. Después de desplazar 5 desde la posición actual hacia la izquierda, el desplazamiento impreso es 6 y finalmente se desplaza desde el principio a 0. , por lo que el desplazamiento es Shift es 0.
El resultado de la inserción interna después de abrir el archivo creado se muestra en la figura (la parte roja no tiene caracteres y no es un espacio\0\n, por lo que no se puede mostrar normalmente)
