Explicação detalhada das operações básicas da programação de arquivos Linux comum
Diretório de artigos
- Explicação detalhada das operações básicas da programação de arquivos Linux comum
- prefácio
- Uma visão geral da programação de arquivos
- 2. Abertura e criação de arquivos
- 3. Gravando e lendo arquivos
- 5. Mova o cursor do arquivo para a operação
- Seis, implementação de instruções cp do applet de operação de arquivo
- 7. Gravar inteiros e estruturas em arquivos
- Oito, operação padrão de biblioteca c de arquivos
- Resumir
prefácio
O seguinte é uma demonstração simples de abrir, ler, escrever e fechar arquivos no
linux e abrir, ler, escrever e fechar arquivos no linux
.
Uma visão geral da programação de arquivos
As operações de arquivo no linux podem ser geralmente divididas em três categorias: abrir, ler e escrever. Outras operações relacionadas são implementadas com base na abertura, leitura e escrita. As seguintes também usarão demonstrações específicas para implementar a entrada de diferentes parâmetros. Claro , Existem muitos outros pequenos detalhes que precisam ser observados na operação do arquivo, como as permissões ao abrir o arquivo, o significado de vários parâmetros e assim por diante.
Na demonstração a seguir, nem todas as situações são implementadas. Você pode realizar diferentes experimentos de acordo com você e todas as operações são semelhantes.
Ao usar funções diferentes, podemos verificar o manual do homem no linux. Para mim, não me lembro deliberadamente de cada função, apenas domino algumas simples. Entenda o significado de cada parâmetro e depois experimente diferentes pequenas demos.
2. Abertura e criação de arquivos
Protótipo de cada função de operação
int open(const char *pathname, int flags);
int close(int fd);
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
int fd = 0; //文件返回描述符
fd = open("./text",O_RDWR); //在当前目录下以可读可写的方式打开
if(fd == -1) //打开失败返回-1 成功返回一个文件流
{
printf("open error\n");
//可读可写 如果没有存在text文件则创建一个 0600 表示可读可写 4(可读) 2（可写) 1(可执行)
fd = open("./text",O_RDWR | O_CREAT,0600);
if(fd > 0)
{
printf("creat file success\n");
}
}
else
{
printf("open success\n");
}
close(fd); //操作完成关闭文件描述符
return 0;
}
}
resultado da operação
3. Gravando e lendo arquivos
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(void)
{
int fd = 0; //接收文件描述符
char writebuf[]="xiao yin student";
char readbuf[128] = {
0}; //读取缓冲
int n_write = 0,n_read = 0; //读写大小返回
fd = open("./text",O_RDWR); //以可读可写方式打开当前目录下text文件
if(fd == -1)
{
printf("open error\n");
}
printf("fd = %d\n",fd); //将文件返回描述符打印出来
n_write = write(fd,writebuf,sizeof(writebuf)); //接内容写入
if(n_write != -1)
{
printf("write %d byte to file\n",n_write);
}
n_read = read(fd,readbuf,n_write); //将文件读取到readbuf
if(n_read != -1)
{
printf("read %d byte to readbuf\n",n_read);
printf("readbuf = %s\n",readbuf);
}
close(fd); //关闭
return 0;
}
Pode-se ver pelos resultados do experimento acima que é diferente do que imaginamos, pois quando escrevemos o conteúdo do arquivo pela primeira vez, o cursor do arquivo se moveu para o final, mas quando leia-o da próxima vez, ele ainda será lido desse lado, então o que escrevemos não será lido. Na próxima demonstração, explicaremos o movimento do cursor e você poderá visualizar novamente os resultados desse experimento.
5. Mova o cursor do arquivo para a operação
O protótipo
da função de cursor é usado apenas aqui, e você mesmo pode verificar os parâmetros
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(void)
{
int fd = 0; //接收文件描述符
char writebuf[]="xiao yin student";
char readbuf[128] = {
0}; //读取缓冲
int n_write = 0,n_read = 0; //读写大小返回
fd = open("./text",O_RDWR); //以可读可写方式打开当前目录下text文件
if(fd == -1)
{
printf("open error\n");
}
printf("fd = %d\n",fd); //将文件返回描述符打印出来
n_write = write(fd,writebuf,sizeof(writebuf)); //接内容写入
if(n_write != -1)
{
printf("write %d byte to file\n",n_write);
}
//写完注意重新将光标置到开头,或者关闭重新打开 要不然读取不到数据
//close(fd);
//fd = open("./text",O_RDWR);
//将光标重新置到开头
lseek(fd,0,SEEK_SET);
n_read = read(fd,readbuf,n_write); //将文件读取到readbuf
if(n_read != -1)
{
printf("read %d byte to readbuf\n",n_read);
printf("readbuf = %s\n",readbuf);
}
close(fd); //关闭
return 0;
}
Seis, implementação de instruções cp do applet de operação de arquivo
No Linux, muitas vezes usaremos a instrução cp copy, então como implementar essa instrução, vamos demonstrar com uma demonstração simples.
A seguir, também usaremos a transferência de parâmetros de função, que será usada com frequência em nosso aprendizado posterior.
#include <stdio.h>
#include <error.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main(int argc,char *argv[])
{
char *ReadBuf = NULL;
int src = 0,des = 0; //源文件和目标文件的描述符
int file_size = 0; //文件读取的大小存储
//判断传入参数是否正确
if(argc != 3)
{
perror("param error\n");
exit(-1);
}
src = open(argv[1],O_RDWR); //以可读可写的 方式打开源文件
if(src == -1) //打开失败
{
printf("src file open failed\n");
}
//将源文件的内容读取到readbuf 缓冲区
file_size = lseek(src,0,SEEK_END); //读取文件大小
lseek(src,0,SEEK_SET); //将文件指针移值开头
ReadBuf = (char *)malloc(file_size*(sizeof(char)) + 8); //开辟缓冲空间大小
read(src,ReadBuf,file_size); //读取内容
//打开目标文件
des = open(argv[2],O_RDWR | O_CREAT,0600);
if(des == -1)
{
perror("des file open failed\n");
}
//将源文件内容读取到目标wenj
write(des,ReadBuf,file_size);
//关闭源文件
close(src);
close(des);
return 0;
}
7. Gravar inteiros e estruturas em arquivos
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
struct Data
{
int a;
char str[24];
};
int main(void)
{
int fd = 0;
struct Data dat1 = {
100,"hello linux"};
struct Data dat2;
fd = open("./text",O_RDWR | O_CREAT,0600);
if(fd == -1)
{
printf("open error\n");
exit(-1);
}
write(fd,&dat1,sizeof(struct Data));
lseek(fd,0,SEEK_SET);
read(fd,&dat2,sizeof(struct Data));
printf("read data:%d %s\n",dat2.a,dat2.str);
close(fd);
return 0;
}
Oito, operação padrão de biblioteca c de arquivos
Existem também várias operações comuns em arquivos na biblioteca c padrão: fopen fwrite fread fseek fclose e open write read lseek clsoe no linux.
一、fopen fwrite fread fclose
函数原型
FILE *fopen(const char *pathname, const char *mode);
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
size_t fwrite(const void *ptr, size_t size, size_t nmemb,
FILE *stream);
int fclose(FILE *stream);
pathname:
modo de nome de arquivo: permissões de operação de arquivo
#include <stdio.h>
#include <string.h>
int main(void)
{
//FILE *fopen(const char *pathname, const char *mode);
FILE *fp;
char str[] = "my linux test";
char readbuf[128]= {
0};
fp = fopen("./text","w+");
if(NULL == fp)
{
printf("fopen error\n");
}
//size_t fwrite(const void *ptr, size_t size, size_t nmemb,
// FILE *stream);
//文件写入
fwrite(str,sizeof(char),strlen(str),fp);
//将光标置到开始位置
fseek(fp,0,SEEK_SET);
//文件读取
// size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
fread(readbuf,sizeof(char),strlen(str),fp);
printf("read data:%s\n",readbuf);
//关闭文件描述符
fclose(fp);
return 0;
}
二, fputc fgetc feof
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *fp;
char c;
fp = fopen("./text","w+");
if(NULL == fp)
{
printf("fopen error\n");
exit(-1);
}
// int fputc(int c, FILE *stream);
//fputc('h',fp);
while(!feof(fp)) //feof 到达文件尾不为0
{
c = fgetc(fp);
printf("c = %c",c);
}
fclose(fp);
return 0;
}
Terceiro, a estrutura é gravada na operação padrão do arquivo da biblioteca c
#include <stdio.h>
#include <string.h>
struct Data
{
int a;
char name[24];
};
int main(void)
{
//FILE *fopen(const char *pathname, const char *mode);
struct Data dat = {
100,"my linux"};
struct Data dat2;
FILE *fp;
fp = fopen("./text","w+");
if(NULL == fp)
{
printf("fopen error\n");
}
//size_t fwrite(const void *ptr, size_t size, size_t nmemb,
// FILE *stream);
//文件结构体写入
fwrite(&dat,sizeof(struct Data),1,fp);
//将光标置到开始位置
fseek(fp,0,SEEK_SET);
//文件读取
// size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
fread(&dat2,sizeof(struct Data),1,fp);
printf("read data:%d %s\n",dat2.a,dat2.name);
//关闭文件描述符
fclose(fp);
return 0;
}
Resumir
As operações de arquivo no Linux foram brevemente demonstradas acima. .