标注C库IO函数和Linux系统IO函数对比_标准c文件io和linux文件io的区别-CSDN博客

本文链接：https://blog.csdn.net/hongyuyahei/article/details/130840102

本文详细介绍了Linux环境下的文件IO操作，包括标准C库的函数如fopen、fclose与Linux系统调用如open、close、read、write的使用。讨论了文件描述符、虚拟地址空间的概念，并举例说明了文件权限设置、文件复制、文件长度调整等功能。此外，还涵盖了目录操作和文件属性管理，如mkdir、rmdir、chmod等。

摘要由CSDN通过智能技术生成

文件IO，从内存角度出发

标准C库IO函数

在这里插入图片描述
标准C库IO函数可跨平台，开发程序可在windows平台和Linu平台运行，不属于第三方库，在不同平台上调用不同平台的系统API。Qt也是跨平台。Java平台实现跨平台，提供虚拟机，在各平台上运行代码一样。
标准C库IO函数更高级，效率更高。
缓冲区，默认8KB
磁盘读写，使用标准C库IO函数，提高系统效率；网络通信使用Linux系统IO，无缓冲。
man 3 fopen，查看具体明细

标准C库IO和Linux系统IO的关系

在这里插入图片描述
调用与被调用的关系，C标准I/O库调用Linux系统IO，Linux系统IO每读写一次，flush一次。

虚拟地址空间

在这里插入图片描述
虚拟地址空间不存在，解决程序加载内存出现的问题，以及解释程序中的堆栈模型等。进程与程序的区别：进程是运行的程序，加载到内存中；程序是磁盘上的代码。32位机器，虚拟地址2^32；64位机器，虚拟地址2的48次方。虚拟地址空间被MMU映射到物理内存。
使用系统调用，通过系统API对内核数据进行操作。

文件描述符

在这里插入图片描述
文件描述符表，是一个数组，可存储n个文件描述符。每个文件描述符都可定位到一个文件。一个进程可同时打开多个文件。默认大小是1024。Linux系统，一切皆文件。一个文件可被打开多次，每次打开的文件描述符不一样，如第一次打开文件进行读操作，第二次打开文件进行写操作。系统调用close可以释放掉文件描述符。

open打开文件

Linux系统IO函数与标准C库IO函数一一对应，如open与fopen
man 2 open，查看具体明细

int open(const char *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);
int close(int fd);
ssize_t read(int fd,void *buf,size_t count)
ssize_t write(int fd,const void *buf,size_t count);
off_t lseek(int fd,off_t offset,int whence);

/*
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>//函数声明

    //打开一个已经存在的文件
    int open(const char *pathname, int flags);//flags定义为宏，放在头文件中
        参数：
            pathname:要打开的文件路径
            -flags:对文件的操作权限及其他设置
                O_RDONLY,  O_WRONLY,   O_RDWR 这三个设置是互斥的
        返回值：返回一个新的文件描述符，如果调用失败，返回-1

    errno:属于Linux系统函数库，库里面的一个全局变量，记录的是最近的错误号

    #include <stdio.h>

    void perror(const char *s);
        s参数：用户描述，比如hello，最终输出的内容是 hello:***（实际的错误报告）
    作用：打印error对应的错误描述

    //创建一个新的文件
    int open(const char *pathname, int flags, mode_t mode);//并非重载，而是可变参数实现


*/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>//函数声明
#include <stdio.h>
#include <unistd.h>


int main(){
    int fd=open("a.txt",O_RDONLY);

    if(fd==-1){
        perror("open");
    }

    //关闭
    close(fd);

    return 0;
}

touch a.txt在当前目录下新建文件

open创建新文件

/*
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    int open(const char *pathname, int flags, mode_t mode);
        参数：
            -pathname:要创建的文件的路径
            -flags:对文件的操作权限和其他的设置
                -必选项：O_RDONLY,  O_WRONLY,  O_RDWR 这三者之间是互斥的
                -可选项：O_CREAT
            -mode：八进制的数，表示用户创建出的新的文件的操作权限，比如：0775
            最终的权限是：mode & ~umask(0002)
            0777 rwxrwxrwx ->111111111
        &   0775           ->111111101
        --------------------------------
                             111111101（去他组不能对文件进行写操作）->用户、本组、其他组
        按位与：0与任何数都为0
        umask的作用就是抹去某些权限！可通过umask 0022将掩码设置成0022但仅对此终端有效


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

int main(){

    //创建一个新的文件
    int fd=open("create.txt",O_RDWR|O_CREAT,0777);
    //按位或：flags是一个int类型的数据，占4个字节，32位
    //flags 32个位，每一位就是一个标志位  

    if(fd==-1){
        perror("open");
    }

    //关闭
    close(fd);
    
    return 0;
}

read、write函数

read：从文件中读取数据到内存中
write：把内存中的数据写到文件当中
结合read和write可实现文件的拷贝功能
解决xftp打开文件中文名乱码：
https://jingyan.baidu.com/article/0bc808fc03296a1bd485b9ed.html

/*  
    #include <unistd.h>
    ssize_t read(int fd, void *buf, size_t count);
        参数：
            - fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
            - buf：需要读取数据存放的地方，数组的地址（传出参数）
            - count：指定的数组的大小
        返回值：
            - 成功：
                >0: 返回实际的读取到的字节数
                =0：文件已经读取完了
            - 失败：-1 ，并且设置errno

    #include <unistd.h>
    ssize_t write(int fd, const void *buf, size_t count);
        参数：
            - fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
            - buf：要往磁盘写入的数据，数组 
            - count：要写的数据的实际的大小
        返回值：
            成功：实际写入的字节数
            失败：返回-1，并设置errno
*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {

    // 1.通过open打开english.txt文件
    int srcfd = open("english.txt", O_RDONLY);
    if(srcfd == -1) {
        perror("open");
        return -1;
    }

    // 2.创建一个新的文件（拷贝文件）
    int destfd = open("cpy.txt", O_WRONLY | O_CREAT, 0664);
    if(destfd == -1) {
        perror("open");
        return -1;
    }

    // 3.频繁的读写操作
    char buf[1024] = {0};
    int len = 0;
    while((len = read(srcfd, buf, sizeof(buf))) > 0) {
        write(destfd, buf, len);
    }

    // 4.关闭文件
    close(destfd);
    close(srcfd);


    return 0;
}

lseek函数

/*
        #include <sys/types.h>//放置一些宏定义
        #include <unistd.h>//Unix标准头文件
        off_t lseek(int fd, off_t offset, int whence);//Linux系统，对文件指针进行操作
            参数：
                -fd:文件描述符，通过open得到的，通过这个fd操作某个文件
                -offset：偏移量
                -whence：
                    SEEK_SET
                        设置文件指针的偏移量

                    SEEK_CUR
                        设置偏移量：当前位置+第二个参数offset的值.

                    SEEK_END
                        设置偏移量：文件大小+第二个参数offset的值
            
            返回值：返回文件指针的位置

            作用：
                1、移动文件指针到文件头
                lseek(fd,0,SEEK_SET);

                2、获取当前文件指针的位置
                lseek(fd,0,SEEK_CUR)

                3、获取文件长度
                lseek(fd,0,SEEK_END);

                4、拓展文件的长度，当前文件10b,拓展成110b,增加了100个字节
                lseek(fd,100,SEEK_END);
                应用：下载文件时，先扩展文件，预留文件大小后再下载数据
                注意：需写一次数据，扩展才生效




        #include <stdio.h>
        int fseek(FILE *stream, long offset, int whence);//标准C库
            
*/

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

int main(){
    int fd=open("hello.txt",O_RDWR);

    if(fd==-1){
        perror("open");
        return -1;
    }

    //扩展文件的长度
    int ret=lseek(fd,100,SEEK_END);
    if(ret==-1){
        perror("lseek");
        return -1;
    }

    //写入一个空数据
    write(fd," ",1);

    //关闭文件
    close(fd);
    
    return 0;
}

stat、lstat函数

vim模式如何进入编辑模式？在需要插入的位置，按下i按键即可
在这里插入图片描述

Linux有七种文件类型。st_mode通过一个或多个标志位表示不同的文件类型。
判断文件权限&与操作
判断文件类型：将st_mode与掩码与操作后，并与具体文件类型进行比较。

/*
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <unistd.h>

        
        int stat(const char *pathname, struct stat *statbuf);
        作用：获取文件的相关信息
        参数：
            -pathname:操作的文件路径
            -statbuf:结构体变量，传出参数，用于保存获取到的信息
        
        返回值：
            0：成功
            -1：失败，并且设置errno

        int lstat(const char *pathname, struct stat *statbuf);//获取软链接文件的信息

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

int main(){
    
    struct stat statbuf;

    int ret=stat("a.txt",&statbuf);

    if(ret==-1){
        perror("stat");
        return -1;
    }
    printf("size:%ld\n",statbuf.st_size);

    return 0;
}

模拟实现ls -l 命令

ls -l罗列当前目录下文件的信息
在这里插入图片描述
ls -l 文件名：罗列出某一个具体的文件

//模拟实现ls-l 指令
//-rw-rw-r-- 1 xiaohong xiaohong 13 5月  25 22:34 a.txt

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>
#include <string.h>

int main(int argc,char *argv[]){

    //判断输入的参数是否正确
    if(argc<2){
        printf("%s filename\n",argv[0]);
        return -1;
    }

    //通过stat函数获取用户传入的文件信息
    struct stat st;
    int ret=stat(argv[1],&st);
    if(ret==-1){
        perror("stat");
        return -1;
    } 

    //获取文件类型和文件权限
    char perms[11]={0};//用于保存文件类型和文件权限的字符串

    switch(st.st_mode & S_IFMT){
        case S_IFLNK:
            perms[0]='l';
            break;
        case S_IFDIR:
            perms[0]='d';
            break;
        case S_IFREG:
            perms[0]='-';
            break;
        case S_IFBLK:
            perms[0]='b';
            break;
        case S_IFCHR:
            perms[0]='c';
            break;
        case S_IFSOCK:
            perms[0]='s';
            break;
        case S_IFIFO:
            perms[0]='p';
            break;
        default:
            perms[0]='?';
            break;
    }

    //判断文件的访问权限

    //文件所有者
    perms[1]=(st.st_mode&S_IRUSR)?'r':'-';
    perms[2]=(st.st_mode&S_IWUSR)?'w':'-';
    perms[3]=(st.st_mode&S_IXUSR)?'x':'-';

    //文件所有者
    perms[4]=(st.st_mode&S_IRGRP)?'r':'-';
    perms[5]=(st.st_mode&S_IWGRP)?'w':'-';
    perms[6]=(st.st_mode&S_IXGRP)?'x':'-';

    //其他人
    perms[7]=(st.st_mode&S_IROTH)?'r':'-';
    perms[8]=(st.st_mode&S_IWOTH)?'w':'-';
    perms[9]=(st.st_mode&S_IXOTH)?'x':'-';

    //硬连接数
    int linkNum=st.st_nlink;

    //文件所有者
    char * fileUser=getpwuid(st.st_uid)->pw_name;

    //文件所在组
    char * fileGrp=getgrgid(st.st_gid)->gr_name;

    //文件大小
    long int fileSize=st.st_size;

    //获取修改的时间
    char * time=ctime(&st.st_mtime);

    char mtime[512]={0};
    strncpy(mtime,time,strlen(time)-1);

    char buf[1024];
    sprintf(buf,"%s %d %s %s %ld %s %s",perms,linkNum,fileUser,fileGrp,fileSize,mtime,argv[1]);

    printf("%s\n",buf);

    return 0; 

}

文件属性操作函数

在这里插入图片描述
1、access

/*
    #include <unistd.h>
    int access(const char *pathname,int mode);
        作用：判断某个文件是否有某个权限，或者判断文件是否存在
        参数：
            -pathname:判断的文件路径
            -mode：
                R_OK：判断是否有读权限
                W_OK:判断是否有写权限
                X_OK:判断是否有执行权限
                F_OK:判断文件是否存在
        返回值：成功返回0，失败返回-1
*/

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

int main(){
    int ret=access("a.txt",F_OK);
    if(ret==-1){
        perror("acess");
        return -1;
    }
    
    printf("文件存在！！！\n");
    

    return 0;
}

2、chmod

/*
    #include <sys/stat.h>
    int chmod(const char* pathname,mode_t mode);
        作用：修改文件的权限
        参数：
            -pathname:需要修改的文件的路径
            -mode：需要修改的权限值，八进制的数
        返回值：成功返回0，失败返回-1
*/

#include <sys/stat.h>
#include <stdio.h>

int main(){

    int ret=chmod("a.txt",0777);

    if(ret==-1){
        perror("chmod");
        return -1;
    }
    
    return 0;
}

3、chown
修改文件的所有者和所在组

int chown(const char* path,uid_t owner,gid_t group);

4、truncate

/*
    #include <unistd.h>
    #include <sys/types.h>
    int truncate(const char* pathname,off_t length);
        作用：缩减或者扩展文件的尺寸至指定的大小
        参数：
            -pathname：需要修改的文件路径
            -length：需要最终文件变成的大小
        返回值：
            成功返回0，失败返回-1
*/

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>

int main(){

    int ret=truncate("b.txt",5);

    if(ret==-1){
        perror("truncate");
        return -1;
    }

    return 0;
}

目录操作函数

在这里插入图片描述
1、mkdir

/*
    #include <sys/stat.h>
    #include <sys/types.h>
    int mkdir(const char* pathname,mode_t mode);
        作用：创建一个目录
        参数：
            pathname：创建的目录路径
            mode：权限，八进制的数，与掩码进行与操作获得最后的权限
        返回值：
            成功返回0，失败返回-1
*/

#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>

int main(){

    int ret=mkdir("aaa",0777);

    if(ret==-1){
        perror("mkdir");
        return -1;
    }
    
    return 0;
}

2、rmdir
只能删除空目录

int rmdir(const char* pathname);

3、rename

/*
    #include <stdio.h>
    int rename(const char *oldpath, const char *newpath);

*/
#include <stdio.h>

int main() {

    int ret = rename("aaa", "bbb");

    if(ret == -1) {
        perror("rename");
        return -1;
    }

    return 0;
}

4、chdir
5、getcwd

/*
    #include <unistd.h>
    int chdir(const char* path);
        作用：修改进程的工作目录
            比如在/home/nowcoder启动了一个可执行程序a.out，进程的工作目录就是/home/nowcoder
        参数：
            path:需要修改的工作目录
        返回值：
            成功返回0，失败返回-1

    #include <unistd.h>
    char * getcwd(char *buf,size_t size);
        作用：获取当前工作目录
        参数：
            -buf:存储的路径，指向的是一个数组（传出参数）
            -size:数组的大小
        返回值：
            返回的指向的一块内存，这个数据就是第一个参数
*/

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

int main(){

    //获取当前的工作目录
    char buf[128];
    getcwd(buf,sizeof(buf));
    printf("当前的工作目录是：%s\n",buf);

    //修改工作目录
    int ret=chdir("/home/xiaohong/Linux/lesson13");
    if(ret==-1){
        perror("chdir");
        return -1;
    }
    
    //创建一个新的文件
    int fd=open("chdir.txt",O_CREAT|O_RDWR,0664);
    if(fd==-1){
        perror("open");
        return -1;
    }

    close(fd);

    //获取当前的工作目录
    char buf1[128];
    getcwd(buf1,sizeof(buf1));
    printf("当前的工作目录是：%s\n",buf1);

    return 0;
}

目录遍历函数

在这里插入图片描述

/*
    //打开一个目录
    #include <sys/types.h>
    #include <dirent.h>
    DIR* opendir(const char *name);
        参数：
            -name:需要打开的目录名称
        返回值：
            DIR* 类型，理解为目录流
            错误返回NULL

    //读取目录中的数据
    #include <dirent.h>
    struct dirent *readdir(DIR *dirp);
        -参数：dirp是opendir返回的结果
        -返回值：
            struct dirent，代表读取到的文件的信息
            读取到了末尾或者失败了，返回NULL

    //关闭目录
    #include <sys/types.h>
    #include <dirent.h>
    int closedir(DIR* drip);
*/

#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int getFileNum(const char* path);

//读取目录下所有的普通文件的个数
int main(int argc,char* argv[]){
    
    if(argc<2){
        printf("%s path\n",argv[0]);
        return -1;
    }

    int num=getFileNum(argv[1]);

    printf("普通文件的个数为：%d\n",num);

    return 0;
}

//用于获取目录下所有普通文件的个数
int getFileNum(const char* path){
    //1、打开目录
    DIR * dir=opendir(path);

    if(dir==NULL){
        perror("opendir");
        exit(0);
    }

    struct dirent *ptr;

    //记录普通文件的个数
    int total=0;

    while((ptr=readdir(dir))!=NULL){

        //获取名称
        char *dname=ptr->d_name;

        //忽略掉.和..
        if(strcmp(dname,".")==0||strcmp(dname,"..")==0){
            continue;
        }

        //判断是否有普通文件还是目录
        if(ptr->d_type==DT_DIR){
            //目录，需要继续读取这个目录
            char newpath[256];
            sprintf(newpath,"%s/%s",path,dname);
            total+=getFileNum(newpath);
        }

        if(ptr->d_type==DT_REG){
            //普通文件
            ++total;
        }
    }

    //关闭目录
    closedir(dir);

    return total;
}

dup、dup2函数

在这里插入图片描述

/*
    #include <unistd.h>
    int dup(int oldfd);
        作用：复制一个新的文件描述符
        fd=3, int fd1 = dup(fd),
        fd指向的是a.txt, fd1也是指向a.txt
        从空闲的文件描述符表中找一个最小的，作为新的拷贝的文件描述符


*/

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

int main() {

    int fd = open("a.txt", O_RDWR | O_CREAT, 0664);

    int fd1 = dup(fd);

    if(fd1 == -1) {
        perror("dup");
        return -1;
    }

    printf("fd : %d , fd1 : %d\n", fd, fd1);

    close(fd);

    char * str = "hello,world";
    int ret = write(fd1, str, strlen(str));
    if(ret == -1) {
        perror("write");
        return -1;
    }

    close(fd1);

    return 0;
}

/*
    #include <unistd.h>
    int dup2(int oldfd,int newfd);
        作用：重定向文件描述符
        oldfd指向a.txt，newfd指向b.txt
        调用函数成功后：newfd和b.txt做close，newfd指向了a.txt
        oldfd必须是一个有效的文件描述符
        若oldfd和newfd值相同，相当于什么都没有做
*/

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

int main(){

    int fd=open("1.txt",O_RDWR|O_CREAT,0664);
    if(fd==-1){
        perror("open");
        return -1;
    }

    int fd1=open("2.txt",O_RDWR|O_CREAT,0664);
    if(fd1==-1){
        perror("open");
        return -1;
    }

    printf("fd:%d,fd1:%d\n",fd,fd1);

    int fd2=dup2(fd,fd1);//fd2与fd1相同
    if(fd2==-1){
        perror("dup2");
        return -1;
    }

    //通过fd1去写数据，实际操作的是1.txt，而不是2.txt
    char* str="hello,dup2";
    int len=write(fd1,str,strlen(str));

    if(len==-1){
        perror("write");
        return -1;
    }

    printf("fd:%d,fd1:%d,fd2:%d\n",fd,fd1,fd2);

    close(fd);
    close(fd1);

    return 0;
}

fcntl函数

在这里插入图片描述

/*

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

    int fcntl(int fd, int cmd, ...);
    参数：
        fd : 表示需要操作的文件描述符
        cmd: 表示对文件描述符进行如何操作
            - F_DUPFD : 复制文件描述符,复制的是第一个参数fd，得到一个新的文件描述符（返回值）
                int ret = fcntl(fd, F_DUPFD);

            - F_GETFL : 获取指定的文件描述符文件状态flag
              获取的flag和我们通过open函数传递的flag是一个东西。

            - F_SETFL : 设置文件描述符文件状态flag
              必选项：O_RDONLY, O_WRONLY, O_RDWR 不可以被修改
              可选性：O_APPEND, O)NONBLOCK
                O_APPEND 表示追加数据
                NONBLOK 设置成非阻塞
        ...:可变参数 
        阻塞和非阻塞：描述的是函数调用的行为。阻塞，返回值返回前当前进程被挂起直到返回。非阻塞，调用函数，立即返回，不会阻塞进程或线程。  
*/

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

int main() {

    // 1.复制文件描述符
    // int fd = open("1.txt", O_RDONLY);
    // int ret = fcntl(fd, F_DUPFD);

    // 2.修改或者获取文件状态flag
    int fd = open("1.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        return -1;
    }

    // 获取文件描述符状态flag
    int flag = fcntl(fd, F_GETFL);
    if(flag == -1) {
        perror("fcntl");
        return -1;
    }
    flag |= O_APPEND;   // flag = flag | O_APPEND

    // 修改文件描述符状态的flag，给flag加入O_APPEND这个标记
    int ret = fcntl(fd, F_SETFL, flag);
    if(ret == -1) {
        perror("fcntl");
        return -1;
    }

    char * str = "nihao";
    write(fd, str, strlen(str));

    close(fd);

    return 0;
}