Linux 文件操作：系统调用与标准库函数接口汇总及代码示例

1.2 系统调用和库函数汇总

1.2.1 系统调用

1.2.2 C 语言标准库文件 IO 函数

2. 文件 IO 部分代码演示

2.1 文件操作 1：打开文件方式

Makefile

myfile:myfile.c
	gcc -o $@ $^
.PHONY:clean
clean:	rm -f myfile

myfile.c

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int main(){
    umask(0);
    // 就近原则
    int fd = open("log.txt", O_CREAT | O_WRONLY | O_TRUNC, 0666);
    // OS 本身自带的系统调用，相当于 w
    if(fd < 0){
        perror("open");
        return 1;
    }
    const char* message = "ccc";
    write(fd, message, strlen(message));
    close(fd);
    return 0;
}

2.2 文件操作 2：重定向

Makefile

myfile:myfile.c
	gcc -o $@ $^
.PHONY:clean
clean:	rm -f myfile

myfile.c

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int main(){
    // 联系重定向
    // 格式化输出：上层的用户层，stdout -> 1
    //printf("hello printf\n"); // stdout -> 1
    //fprintf(stdout,"hello fprintf\n"); // stdout -> 1

    // 三个标准流，默认打开的
    //printf("stdin: %d\n",stdin->_fileno);
    //printf("stdout: %d\n",stdout->_fileno);
    //printf("stderr: %d\n",stderr->_fileno);

    FILE *fp = fopen("log.txt","w");
    //printf("log.txt: %d\n",fp->_fileno); // 3（fd 数组下标）
    fprintf(stdout,"hello stdout\n");
    close(1);

    int fda = open("loga.txt",O_CREAT | O_WRONLY | O_TRUNC,0666);
    int fdb = open("logb.txt",O_CREAT | O_WRONLY | O_TRUNC,0666);
    int fdc = open("logc.txt",O_CREAT | O_WRONLY | O_TRUNC,0666);
    fprintf(stdout,"fda : %d\n",fda);
    fprintf(stdout,"fdb : %d\n",fdb);
    fprintf(stdout,"fdc : %d\n",fdc);

    close(fda);
    close(fdb);
    close(fdc);
    return 0;
}

loga.txt

fda :1 fdb :4 fdc :5

2.3 文件操作 3：理解缓冲区

Print.c

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>

int main(){
    printf("hell world"); // 语言缓冲区 -> stdout->outbuffer
    sleep(40); // 测试杀死这个进程

    // C 库函数
    //printf("hello printf\n");
    //fprintf(stdout,"hello fprintf\n");
    //const char *msg1 = "hello fputs\n";
    //fputs(msg1,stdout);

    // 系统调用
    // const char *msg2 = "hello write\n";
    // write(1,msg2,strlen(msg2));
    //fork(); // 最后 return 0;
    return 0;
}

2.4 文件操作 4：实现 stdio

Makefile

testlibc:main.c my_stdio.c
	gcc -o $@ $^
.PHONY:clean
clean:	rm -f testlibc

main.c

#include"my_stdio.h"
#include<string.h>
#include<unistd.h>

int main(){
    My_FILE *fp = Myfopen("log.txt","a"); // 相当于把这个 log.txt 当显示器了
    if(!fp) // 打开文件失败或者底层 malloc 失败
        return 1;
    int cnt = 10;
    const char* msg = "hello world ";
    while(cnt--){
        Myfwrite(msg,1,strlen(msg),fp); // 模拟缓存的行为
        Myfflush(fp);
        sleep(2);
    }
    Myfclose(fp);
    return 0;
}

my_stdio.h

#pragma once

typedef struct{
    int fd;
    int flags;
    int mode; // 刷新策略
    char outbuffer[1024];
    int cap; // 缓冲区总容量
    int size; // 缓冲区当前的数据量
} My_FILE;

// 定义宏，是什么类型的缓冲
#define NONE_CACHE 1
#define LINE_CACHE 2
#define FULL_CACHE 4
// 1 2 4 只有一个比特位为 1（0001/0010/0100），检测起来比较容易

My_FILE *Myfopen(const char* pathname,const char* mode); // r w a 方式 --> 打开文件
int Myfwrite(const char* message,int size,int num,My_FILE *fp); // 写文件
void Myfflush(My_FILE *fp); // 刷新
void Myfclose(My_FILE *fp); // 关闭文件

my_stdio.c

#include"my_stdio.h"
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<stdlib.h> // malloc
#include<unistd.h>

static mode_t global_mode = 0666;

My_FILE *Myfopen(const char* pathname,const char* mode){ // r w a 方式 (在内部选择不同的模式)
    if(pathname == NULL || mode == NULL)
        return NULL;
    umask(0);
    int fd = 0;
    int flags = 0;
    if(strcmp(mode,"w")==0){
        flags = O_CREAT | O_WRONLY | O_TRUNC;
        fd = open(pathname,flags,global_mode);
    }
    if(strcmp(mode,"r")==0){
        flags = O_RDONLY;
        fd = open(pathname,flags);
    }
    if(strcmp(mode,"a")==0){
        flags = O_CREAT | O_WRONLY | O_APPEND;
        fd = open(pathname,flags,global_mode);
    }

    if(fd < 0) // 文件打开失败
        return NULL;

    // 创建 My_FILE 对象
    My_FILE* fp = (My_FILE*)malloc(sizeof(My_FILE));
    if(!fp) // 声明失败，直接返回
        return NULL;

    fp->fd = fd;
    fp->flags = flags;
    fp->mode = LINE_CACHE;
    fp->cap = 1024; // 容量，因为缓冲区大小定义的就是 1024，这一块也可以定义成宏
    fp->size = 0; // 当前缓冲区里没有数据，size 是 0
    memset(fp->outbuffer,0,sizeof(fp->outbuffer));
    return fp; // 至此上层拿到了这个被打开的文件
}

int Myfwrite(const char* message,int size,int num,My_FILE *fp){ // 一定程度上减少系统调用次数
    if(message == NULL || fp == NULL)
        return -1;

    int total = size * num;
    if(total + fp->size > fp->cap -1) // 保证不会越界 --> 总容量给\0 留个位置
        return -1;

    // 写入 --> 就相当于在进行数据拷贝 --> 核心 memcpy
    memcpy(fp->outbuffer + fp->size,message,total);
    fp->size += total;
    fp->outbuffer[fp->size]=0;

    if(fp->outbuffer[fp->size -1]=='\n' && (fp->mode & LINE_CACHE))
        Myfflush(fp); // 如果字符串结尾是\n，并且模式是 LINE(行缓冲)，就直接强制刷新

    return num;
}

void Myfflush(My_FILE *fp){
    if(!fp)
        return;

    if(fp->size >0) // 强制刷新，只要有数据就刷新
    {
        // 系统调用
        // 所谓的刷新就是把数据从用户缓冲区拷贝到内核
        // 像从用户缓冲区拷贝到内核这种模式叫做 WB 模式
        // WB: Write Back(写回)
        write(fp->fd,fp->outbuffer,fp->size);
        fp->size = 0; // 清空

        // WT 模式，Write Though
        // 不仅仅要写入到内核缓冲区，还必须写到对应的硬件上
        fsync(fp->fd); // 强度做大一点
    }
}

void Myfclose(My_FILE *fp){ // 关闭文件
    if(!fp)
        return;
    Myfflush(fp); // 只要有数据，无脑刷新
    close(fp->fd); // 先刷新再关闭！先刷新，再关闭文件描述符！
}