【Linux】基础IO——库函数与系统调用的关系

最新推荐文章于 2024-05-06 21:21:21 发布
最新推荐文章于 2024-05-06 21:21:21 发布
阅读量949 收藏 3
点赞数 3
文章标签： linux 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57163217/article/details/130458197
版权

目录

引言

打开文件的本质，就是将该文件的属性加载到内存中，OS内部存在大量被打开的文件，所以就需要管理这些文件：
每打开一个文件，都要在OS内创建该文件对象的struct结构体，然后将这些struct file用某种数据结构链接起来，所以在OS内部对文件的管理就转化成了对链表的增删查改。
在这里插入图片描述

文件可以分为两大类：

  1. 磁盘文件：没有被打开，存储在磁盘上
  2. 被打开的文件：被打开了，在内存中创建了对应的数据结构管理文件的属性

文件是被OS打开的，谁让OS打开？
——进程，所以我们所学习的都是 进程 与 被打开文件 的关系（struct task_struct 与 struct file）；

1.文件操作语言方案（C的文件操作接口-库函数）

要对文件进行操作，首先要打开文件，打开操作完成后也要关闭文件，下面复习两个接口，fopen与fclose；

打开文件、关闭文件——fopen、fclose

打开文件——fopen
头文件：stdio.h
函数：FILE *fopen(const char *path, const char *mode);
参数：
path——打开文件的路径；
mode——打开文件的模式；
返回值：成功返回FILE的指针，失败返回NULL；
若失败会设置错误码errno（表明出错的原因），可以通过perror接收错误码，将错误码转化成错误码描述打印错误原因，也可以通过strerror将错误码转化成错误码字符串；

关闭文件——fclose
头文件：stdio.h
函数：int fclose(FILE *fp);
参数：pf：指向被打开的文件
返回值：成功返回0，失败返回EOF，并设置错误码errno。

打开文件的模式

打开模式含义若指定文件不存在
“r”（只读）为了输入数据，打开一个已经存在的文本文件出错
“w”（只写）为了输出数据，打开一个文本文件创建新文件
“a”（追加）向文本文件尾添加数据创建新文件
“rb”（只读）为了输入数据，打开一个二进制文件出错
“wb”（只写）为了输出数据，打开一个二进制文件创建新文件
“ab”（追加）向一个二进制文件尾添加数据出错
“r+”（读写）为了读和写，打开一个文本文件出错
“w+”（读写）为了读和写，建立一个新的文件创建新文件
“a+”（读写）打开一个文件，在文件尾进行读写创建新文件
“rb+”（读写）为了读和写打开一个二进制文件出错
“wb+”（读写）为了读和写，新建一个新的二进制文件创建新文件
“ab+”（读写）打开一个二进制文件，在文件尾进行读和写创建新文件

解析：
如果fopen以w模式打开文件，写入的规则是：
1.首先将文件清空
2.从重头重新写入
（若只打开文件，不写入就关闭，文件也会被清空）

如果fopen以a模式打开文件，写入的规则是：
不会清空文件，每次写入都是从文件的结尾写入。

写入——fput、printf

1.fputs
打开文件后还需要进行写入操作，写入操作接口有很多，这里复习fputs。

写入——fputs
头文件：stdio.h
函数：int fputs(const char *s, FILE *stream);
参数：将字符串s写入到文件流stream当中。
返回值：成功返回非负数（写入了多少个字符），错误返回EOF；

以一段最简单的代码为例：在当前目录下创建log.txt文件，并写入5条hello world！。

//fputs文件写入
#include <stdio.h>

#define LOG "log.txt"

int main()
{
    FILE *fp = fopen(LOG, "w");
    if(fp == NULL)
    {
        perror("fopen");
        return 1;
    }

    const char *str = "hello world!\n";
    int cnt = 5;
    while(cnt)
    {
        fputs(str, fp);
        cnt--;
    }

    fclose(fp);
    return 0;
}

2.printf、fprintf、sprintf、snprintf

头文件：stdio.h
函数：

int printf(const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int sprintf(char *str, const char *format, ...);
int snprintf(char *str, size_t size, const char *format, ...);

解析：
printf——默认向显示器打印，很熟悉，不解析。（显示器也是文件，对应标准输出流stdout）
fprintf——指定文件流stream，向指定文件打印；第二个参数format是格式化控制（与printf一样）
sprintf——向缓冲区打印；可以以格式化流的方式，将格式化信息输出到自定义的缓冲区str里。
snprintf——与sprintf一样，多了一个参数size是缓冲区的大小。

注：
Linux下一切皆文件，显示器也是一个文件，所以：若fprintf(stdout, str);则与printf(str);一样向显示器打印。

读取——fgets

fgets

头文件：stdio.h
函数：char *fgets(char *s, int size, FILE *stream);
参数：从特定的文件流stream中，按行读取对应的内容，将读到的内容放入缓冲区s中，size是缓冲区的大小
返回值：成功返回字符串的起始地址，失败返回NULL。

2.文件操作系统方案（系统的文件操作接口-系统调用）

打开文件、关闭文件——open、close

open：

头文件：
sys/types.h
sys/stat.h
fcntl.h
函数：
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
参数：
pathname——要打开的文件路径+文件名
flags——打开文件对应的选项（比如读、写）
mode——打开文件的权限（文件的权限，rwx，比如0666）
返回值：
成功返回文件描述符（file descriptor），失败返回-1；

close：

头文件：
unistd.h
函数：
int close(int fd);

open的参数flags的理解

1.系统是如何给一个函数传递多个标志位的？
——比如想给一个函数传递多个标志位，肯定不能设置多个形参比如int func(int flag1, int flag2, int flag3)。又因为传入的标志位flag是int型，有32个比特位，我们可以用1个比特位表示1个标志位，一个整数就可以同时传递32个标志位了——位图。
一般就是使用下面的这种方式传递标志位：

#define ONE 0x1
#define TWO 0x2
#define THREE 0x4
#define FOUR 0x8
#define FIVE 0x10

void Print(int flag)
{
    if(flag & ONE) printf("ONE\n");
    if(flag & TWO) printf("TWO\n");
    if(flag & THREE) printf("THREE\n");
    if(flag & FOUR) printf("FOUR\n");
    if(flag & FIVE) printf("FIVE\n");
}

int main()
{
	//测试
    Print(ONE);
    Print(TWO);
    Print(THREE);
    Print(FOUR);
    Print(FIVE);
    printf("----------\n");
    Print(ONE|TWO);
    printf("----------\n");
    Print(ONE|TWO|THREE);
    printf("----------\n");
    return 0;
}

结果：
在这里插入图片描述

而我们在查看open的参数flag的时候，发现有很多参数（如下图所示，没有截全），这些其实就是宏值，每个宏对应的数字比特位是不重叠的，每个对应一个选项，所以学习时学习每个的含义就可以了。
在这里插入图片描述

open的参数flag的学习

1.O_CREAT——文件存在就打开，不存在就创建
（一般创建新文件不使用两个参数的open，因为权限会乱码，要使用三个参数的open函数，指定文件权限）
2.O_WRONLY——只写
（O_WRONLY | O_CREAT默认不会对原始文件内容做清空！重复写入的时候会很乱，可以自己尝试）
3.O_TRUNC——对文件内容做清空
4.O_APPEND——追加（没有写入，只是追加）
（追加一般不和清空一起使用，因为逻辑上就有矛盾）
5.O_RDONLY——只读
（读取是对一次已经存在的文件读取，所以使用两个参数的open，不用指定文件权限）

使用例：

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

#define LOG "log.txt"

int main()
{
    int fd = open(LOG, O_CREAT | O_WRONLY, 0666);
    if(fd == -1)
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    else
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    close(fd);
}

在这里插入图片描述
此时发现生成的文件权限不是指定的666，而是664，这是为什么？
——因为存在权限掩码umask，umask的计算：最终权限 = 起始权限 & (~umask)，普通用户的umask为0002，所以生成的权限是664。

那么我们要如何不让权限掩码影响我们，直接生成指定权限的文件呢？
——调用umask函数，可以设定当前进程启动时，属于自己的umask。
当该进程生成文件的时候，umask用系统的还是该进程的？
——就近原则，离谁更近就用谁的，所以肯定是用当前进程的umask。

umake：设定进程的权限掩码
头文件：
sys/types.h
sys/stat.h
函数：
mode_t umask(mode_t mask);
参数：想要设定的权限掩码

//头文件略
int main()
{
    umask(0);
    int fd = open(LOG, O_CREAT | O_WRONLY, 0666);
    if(fd == -1)
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    else
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    close(fd);
    return 0;
}

此时发现生成的文件权限掩码与自己设定的一致。
在这里插入图片描述

写入——write

头文件：unistd.h
函数：ssize_t write(int fd, const void *buf, size_t count);
参数：
fd——文件描述符（open的返回值）
buf——缓冲区
count——写入的字符数
将缓冲区中count大小的数据写入到fd中。
返回值：实际写了多少字节，失败返回-1；

读取——read

头文件：unistd.h
函数：ssize_t read(int fd, void *buf, size_t count);
参数：
fd——文件描述符（open的返回值）
buf——缓冲区
count——空间的大小（字节数）
从文件描述符fd中，将数据按数据块的方式读取出来，读取到buf中，读取conut个字节
返回值：读取了多少字节，失败返回-1；

几个系统调用的使用

使用1：
O_WRONLY只写入

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

#define LOG "log.txt"

int main()
{
    umask(0);
    int fd = open(LOG, O_CREAT | O_WRONLY | O_TRUNC, 0666);//打开/创建文件+只写+清空
    if(fd == -1)
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    else
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }

    const char *str = "hello world!";
    int cnt = 5;
    while(cnt)
    {
        char line[128];
        snprintf(line, sizeof(line), "%s, %d\n", str, cnt);
        write(fd, line, strlen(line));//strlen不计算\0，但是这里不+1，因为\0是C语言的规定，不是文件的规定！！
        cnt--;
    }
    close(fd);
    return 0;
}

结果1：
在这里插入图片描述

使用2：
O_WRONLY | O_APPEND追加写入（不带清空）

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

#define LOG "log.txt"

int main()
{
    umask(0);
    int fd = open(LOG, O_CREAT | O_WRONLY | O_APPEND, 0666);//追加写入
    //int fd = open(LOG, O_CREAT | O_WRONLY | O_TRUNC, 0666);//打开/创建文件+只写+清空
    if(fd == -1)
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    else
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }

    const char *str = "hello world!";
    int cnt = 5;
    while(cnt)
    {
        char line[128];
        snprintf(line, sizeof(line), "%s, %d\n", str, cnt);
        write(fd, line, strlen(line));//strlen不计算\0，但是这里不+1，因为\0是C语言的规定，不是文件的规定！！
        cnt--;
    }
    close(fd);
    return 0;
}

结果2：
运行多次，可以发现是追加写入。
在这里插入图片描述

使用3：O_RDONLY读取
（这里读取的就是使用2中生成的文件）

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

#define LOG "log.txt"

int main()
{
    umask(0);
    int fd = open(LOG, O_RDONLY);//只读
    if(fd == -1)
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }
    else
    {
        printf("fd: %d, errno: %d, errstring: %s\n", fd, errno, strerror(errno));
    }

    char buffer[1024];
	//sizeof会计算\0,IO操作一定要注意\0的问题！记得-1
    ssize_t n = read(fd, buffer, sizeof(buffer)-1);
    if(n > 0)
    {
        buffer[n] = '\0';
        printf("%s", buffer);
    }
    close(fd);
    return 0;
}

结果3：
读取成功（我们这里是一个一个读取的，不是和C接口一样按行读取，要实现需要精细化处理）
在这里插入图片描述

3.库函数与系统调用的关系

C语言的接口（库函数）一定调用了系统调用接口，是上下层关系。

在这里插入图片描述
程序员与系统调用接口的关系：
我们平时使用的C、C++库都是对系统调用的封装！

而函数库也是人写的，他们与我们同样不可能绕过OS来对硬件做操作，同时也无法直接操作操作系统，所以只能通过系统调用的方式来操作硬件设备。
在这里插入图片描述
同时其他所有语言都是一样的，都要调用这些系统调用接口，只是封装的形式不同！
在这里插入图片描述

有够会啦
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
系统调用与库函数的关系
m0_47170940的博客
04-02 1403
系统调用与库函数 1、系统调用 操作系统负责管理和分配所有的计算机资源。为了更好地服务于应用程序，操作系统提供了一组特殊接口——系统调用。 通过这组接口用户程序可以使用操作系统内核提供的各种功能。例如分配内存、创建进程、实现进程之间的通信等。 用户程序向操作系统提出请求的接口就是系统调用。 所有的操作系统都会提供系统调用接口，只不过不同的操作系统提供的系统调用接口各不相同。 Linux 系统调用接口非常精简，它继承了Unix 系统调用中最基本的和最有用的部分。 这些系统调用按照功能大致可分为进程控制、进程间
Linux C中库函数与系统调用的区别详细解析
09-15
在Linux C编程中，库函数和系统调用是两个关键的概念，它们在程序设计和执行过程中扮演着不同的角色。理解它们之间的差异对于优化代码性能和提高程序的可移植性至关重要。 首先，库函数是程序员在用户空间中可以...
系统调用与库函数调用的区别
钱国正的专栏
08-16 1179
1、系统调用和库函数的关系 系统调用通过软中断int 0x80从用户态进入内核态。 函数库中的某些函数调用了系统调用。 函数库中的函数可以没有调用系统调用，也可以调用多个系统调用。 编程人员可以通过函数库调用系统调用。 高级编程也可以直接采用int 0x80进入系统调用
【Linux】基础IO——系统文件IO&amp；fd&amp；重定向&amp；理解_linux fd0(4)
最新发布
05-06 752
最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！小总结：我们上面学习了open/close/write/read接口，当然还有lseek接口，这里就不展开说了实际上，这上面四个系统调用接口就对应着C语言的fopen/fclose/fwrite/fread,以及fseek库接口。上面的 fopen fclose fread fwrite 都是C标准库当中的函数，我们称之为库函数（libc）。
库函数和系统调用的区别和联系
乐行僧的博客
07-01 5455
一、库函数和系统调用概念 库函数：库函数是语言或应用程序的一部分，可以运行在用户空间中。 系统调用：又称广义指令，它是由操作系统向程序提供的程序接口，而非直接向用户提供，用户只能通过程序间接的使用这些接口。 1.在概念对比中，可以直观的感触到系统调用是依赖于操作系统的，由于其依赖于平台，所以系统调用的平台移植性较差。 2.而函数库，是将一些已经编写好函数进过封装，存放到函数库（静态库或动态...
库函数与系统调用的联系与区别
diaoju3333的博客
01-04 484
一. 概念 系统调用（英语：system call），指运行在用户空间的应用程序向操作系统内核请求某些服务的调用过程。系统调用提供了用户程序与操作系统之间的接口。一般来说，系统调用都在内核态执行。由于系统调用不考虑平台差异性，由内核直接提供，因而移植性较差（几乎无移植性）。 库函数（library function），是由用户或组织自己开发的，具有一定功能的函数集合，一般具有较好平...
库函数与系统调用的区别与联系
rekkles233的博客
11-21 417
库函数是语言或应用程序的一部分，可以运行在用户空间中。 系统调用是操作系统的一部分，是操作系统内核为用户提供的程序接口，运行在内核空间中。 许多库函数都会使用系统调用来实现功能，未使用系统调用的库函数，其执行效率通常要比系统调用的高，这是因为使用系统调用时，需要上下文切换及状态的切换（由用户态转向核心态） ...
UNIXLinux系统程序、库函数、系统调用分层关系.swf
09-18
UNIXLinux系统程序、库函数、系统调用分层关系.swf
Linux命令行与shell脚本编程、Linux C库函数及系统调用编程、Linux内核分析即应用.zip
03-05
Linux命令行与shell脚本编程、Linux C库函数及系统调用编程、Linux内核分析即应用、Debian（Ubuntu、Deepin）操作系统爬坑.zip Linux命令行与shell脚本编程、Linux C库函数及系统调用编程、Linux内核分析即应用、...
Linux命令行与shell脚本编程、Linux C库函数及系统调用编程、Linux内核分析即应用、Debian系统爬坑.zip
03-03
Linux命令行与shell脚本编程、Linux C库函数及系统调用编程、Linux内核分析即应用、Debian（Ubuntu、Deepin）操作系统爬坑.zip Linux命令行与shell脚本编程、Linux C库函数及系统调用编程、Linux内核分析即应用、...
linux 系统调用与标准库调用的区别详细解析
09-15
在Linux系统中，系统调用和标准库调用是两种不同的程序接口，它们在执行方式、性能和功能上有显著的差异。以下是关于这两种调用的详细解析： 1. **系统调用**： - **作用**：系统调用是操作系统提供给用户程序的...
库函数和系统调用的联系与区别
qq_51725723的博客
08-31 2662
这里写自定义目录标题一、系统调用的概念库函数系统调用的意义功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、系统调用的概念 系统调用我们可以理解为是操作系统为用户提供的一系列操作的接口（API），这些接口提供了对系统硬件设备功能
浅谈C语言函数调用与系统调用
weixin_38815998的博客
11-12 5300
1. 函数调用和系统调用概述 1.1 定性的去区分函数调用和系统调用 很多初学C语言的同学，亦或者开发中很少接触系统底层的同学可能会认为函数调用以及系统调用是一回事。因为在应用程序，两者都被抽象成接口去给应用程序调用。其实函数调用和系统调用还是有区别，我们通过下图先有个全局的了解！ 图1-1 系统功能模块关联图 从图1-1 我们可以知道应用程序访问内核，主要通过两种方式：中断和系统...
库函数和系统调用的区别
清梦旅人的博客
03-11 2196
库函数和系统调用的区别 概念 库函数调用是语言或应用程序的一部分，而系统调用是操作系统的一部分，跨平台技术的原理就是通过库函数实现的，库函数可以理解为是对系统调用的一层封装，但库函数不是必须包含系统调用。 库函数有可能包含有一个系统调用，有可能有好几个系统调用，当然也有可能没有系统调用，比如有些操作不需要涉及内核的功能。 区别 所有 C 函数库是相同的，而各个操作系统的系统调用是不同的。 函数库调用是调用函数库中的一个程序，而系统调用是调用系统内核的服务。 函数库调用是与用户程序相联系，而系统调用是
[Linux] 基础IO控制 -- 文件操作接口
giturtle's blog
04-10 1255
基础IO： 回顾标准库io接口： fopen、fclose、fwrite、fread、fseek stdin、stdout、stderr 文件流函数，类型：FILE* fopen： 【写】覆盖式写入 r 只读 r+ 可读可写，每次都在文件首部开始，覆盖式读写 w 只写，文件不存在则创建，存在则清空内容 truncate:截断file to zero length截断点为0............
Linux系统文件编程基本操作
m0_72442663的博客
03-05 598
Linux系统文件编程的基本操作
Linux 1.文件编程（open、creat、write、read、lseek）
黄色的拉拉的博客
08-16 1713
Linux 1.文件编程文件的打开及创建（open和creat）open函数的头文件 文件的打开及创建（open和creat） open函数的头文件 #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode);
1.3 creat简介
Scroll_C的博客
03-02 831
1.3 creat简介 creat函数用于创建一个新文件，其等价于 open（pathname，O_WRONLY|O_CREAT|O_TRUNC，mode）。 APUE介绍了引入creat的原因： 由于历史原因，早期的Unix版本中，open的第二个参数只能是0、1或者2。这样就没有办法打开一个不存在的文件。因此，一个独立系统调用creat被引入，用于创建新文件。现在的open函数，通过使用O_CREAT和O_TRUNC选项，可以实现creat的功能，因此creat已经不是必要的了。 内核crea
Unix下的C编程：库函数与系统调用关系解析
特别提到了C库函数malloc与系统调用sbrk之间的关系，以及Unix的历史和主要派生版本，包括System V、Berkley和Hybrid，以及这些派生版本下的不同操作系统，如AIX、Solaris、FreeBSD、NetBSD、OpenBSD、MacOS X和Linux...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值