【文件fd】C++文件操作 | 详解系统调用接口文件操作 | 系统调用接口&库函数

唐唐思

已于 2024-07-26 15:12:09 修改

阅读量395

点赞数 11

分类专栏： Linxu系统编程文章标签： Linux 系统文件操作

于 2024-07-26 11:05:22 首次发布

本文链接：https://blog.csdn.net/m0_74841364/article/details/140704685

版权

Linxu系统编程专栏收录该内容

46 篇文章 0 订阅

订阅专栏

3.7.1 O_WRONLY | O_CREAT

3.7.2 O_WRONLY | O_CREAT | O_TRUNC

3.7.3 O_WRONLY | O_CREAT | O_APPEND

3.7.4 flags选项和C语言的"w""a"方式二者存在什么关系❓

1.回顾理解&引出问题

C语言文件操作，写代码/编码的时候，调用fopen，文件根本没有被打开。只有当可执行程序，形成进程，在CPU上执行，运行到fopen那行代码的时候，文件才被动态的打开了。语言编译好，运行起来就是进程。
操作文件的本质：进程在操作文件。是进程和文件的关系。
没有被打开的文件是存在于磁盘上的。
磁盘是一个外部设备。外设是硬件。磁盘是硬件设备。
向文件中写入，向磁盘当中写入，本质就是向硬件当中写入。
用户向硬件写入是不被允许的❗用户没有权力直接向硬件写入和访问。
硬件的管理者是操作系统OS。必须通过OS写入和访问。用的是fopen/fread/fwrite等的的C语言库函数。

为了用户有更好的文件操作体验（用户有写入和访问硬件的需求）OS支持------>给用户提供系统调用接口（OS不相信任何人）------>用户用都是不同语言提供的不同库函数文件操作接口-------->意味着我们使用的C/C++等语言都是对系统调用的封装的库函数

访问文件，用户不仅可以使用各种语言提供的各种库函数，可以使用系统调用❗

C/C++等语言的文件操作库函数都是对系统调用接口的封装。

怎么封装❓为什么封装❓

上层语言对文件访问是不一样的。难道我们每学一个语言，我们都需要去学习这个语言的文件操作吗❓

2.C++文件操作

C/C++等其他语言，访问文件的方式，文件操作的库函数接口有些不一样❗

3.系统调用文件操作

3.0准备工作

先用和认识系统调用的文件操作。

系统调用手册查询：2号手册。

3.1版本1☞open

man 2 open
头文件：#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h>
Open打开文件操作，两种写法（两个参数/三个参数）
两个参数：int open(const char *pathname, int flags);
三个参数：int open(const char *pathname, int flags, mode_t mode);

两个参数的写法：一般用来操作已经存在的文件

三个参数的写法：一般用来操作没有存在的文件

第一个参数pathname:打开的文件是谁。可以带路径，也可以只有文件名（如果只有文件名，此文件就在在当前的路径下创建文件☞进程的当前工作路径）

第二个参数flags:代表的是怎么去创建文件，文件打开方式。flage是整数，但是它可以传递很多标记位。❓flags后面详谈

第三个参数mode：设置文件权限。

返回值：一旦文件被打开，成功就会返回一个整数☞文件描述符fd☞一个新的数字。失败，-1被返回和错误码被设置。

【版本1】log.txt文件确实在进程的当前工作路径被创建，但是创建的log.txt文件的权限是乱码/不正确。❗所以在LinuxOS中新建文件，必须告知新建文件的起始权限是什么。

【版本1】

  1 #include<stdio.h>
  2 #include <sys/types.h>
  3 #include <sys/stat.h>
  4 #include <fcntl.h>
  5 
  6 int main()
  7 {
  8   int fd = open("log.txt",O_WRONLY | O_CREAT);
  9   if(fd < 0)
 10   {
 11     perror("open");
 12     return 1;                                                                                                                           
 13   }
 14 }

【运行结果】

3.2版本2☞文件权限

运行结果是0664而不是0666❓为什么是0664❓
因为在Linux系统中存在权限掩码。0666经过☞权限掩码0002☞变成了0664（之前讲过）如果就想创建文件的权限为0666，不要权限掩码。动态设置当前进程创建文件的权限掩码。

 1: myfile.c
  1 #include<stdio.h>
  2 #include <sys/types.h>
  3 #include <sys/stat.h>
  4 #include <fcntl.h>
  5 
  6 int main()
  7 {
  8   int fd = open("log.txt",O_WRONLY | O_CREAT,0666);//给出文件权限0666                                                                   
  9   if(fd < 0)                                                                    
 10   {                                                                             
 11     perror("open");                                                             
 12     return 1;                                                                   
 13   }                                                                             
 14 }

3.3版本3☞权限掩码

man 2 umask
让可执行程序在运行的时候，形成进程，进程的权限掩码被动态的设置。使创建的文件log.txt的权限掩码改变了。（从使用系统OS的权限☞使用自定义的权限掩码）
umask是代码编译形成可执行程序，运行时候，形成进程。动态调整当前进程创建文件时的权限掩码
系统还是存在自己的权限掩码。就近原则。有系统就用系统的，有自己设置，自定义的，的就用自己设置的。

 1: myfile.c+ 
  1 #include<stdio.h>
  2 #include <sys/types.h>
  3 #include <sys/stat.h>
  4 #include <fcntl.h>
  5 
  6 int main()
  7 {
  8   umask(0);//动态设置当前进程的权限掩码                                                                                                 
  9   int fd = open("log.txt",O_WRONLY | O_CREAT,0666);//给出文件权限0666                                           
 10   if(fd < 0)                                                                                                    
 11   {                                                                                                             
 12     perror("open");                                                                                             
 13     return 1;                                                                                                   
 14   }                                                                                                             
 15 }

3.4版本3☞标记位传参

C语言学习的时候，对函数传递一个标记位（功能选项）。传递标记位可能传很多，难道我们每次都要设置很多的标记位去传参吗❓（以整数的方式传递）这种方式存在的问题：代码不好维护，且浪费时间，使用起来很不方便。
标记位：一般传0/1，或者表示有或没有的概念。
OS设计很多系统调用接口的常见方法：一个flags整数有32个bite位。用比特位来对标志位的进行传递。flage看起来是一个整数，是32个比特位，也是一个位图。

选项的本质：都是比特位为1的宏，彼此之间宏值不重复。flags整数位图☞宏☞不同选项☞不同的文件操作功能

因为OS设计很多系统调用接口的常见方法，为了更加深入的理解标志位传参。我们设计一个传递位图标记位的函数。

 1: flags.c 
  1 #include<stdio.h>
  2 #include<sys/types.h>
  3 #include<fcntl.h>
  4 
  5 #define ONE 1        //1 0000 0001
  6 #define TWO (1<<1)   //2 0000 0010
  7 #define THREE (1<<2) //4 0000 0100
  8 #define FOUR (1<<3)  //8 0000 1000
  9                      //  0000 1111
 10 
 11 void print(int flags)
 12 {
 13   if(flags&ONE)
 14     printf("one\n");
 15   if(flags&TWO)
 16     printf("two\n");
 17   if(flags&THREE)
 18     printf("three\n");
 19   if(flags&FOUR)
 20     printf("four\n");
 21 }
 22 
 23 int main()
 24 {
 25   print(ONE);
 26   printf("\n");
 27 
 28   print(TWO);
 29   printf("\n");
 30 
 31   print(THREE);                                            
 32   printf("\n");
 33 
 34   print(FOUR);
 35   printf("\n");
 36 
 37   print(ONE|TWO|THREE);
 38   printf("\n");
 39 
 40   print(ONE|FOUR);                                         
 41   printf("\n");
 42   
 43   print(THREE|FOUR);
 44   printf("\n");
 45   
 46   return 0;
 47 }

3.5版本4☞close

man 2 close
参数fd文件描述符

 1: myfile.c 
  1 #include <stdio.h>                                          
  2 #include <unistd.h>  
  3 #include <sys/types.h>  
  4 #include <sys/stat.h>                   
  5 #include <fcntl.h>                      
  6                                         
  7 int main()                              
  8 {                                        
  9   umask(0);//动态设置当前进程的权限掩码   10   int fd = open("log.txt",O_WRONLY | O_CREAT,0666);//给出文>    件权限0666                              
 11   if(fd < 0)                            
 12   {                                     
 13     perror("open");                     
 14     return 1;                           
 15   }                                     
 16                                         
 17   close(fd);                            
 18   return 0;                             
 19 }

3.6版本5☞write

man 2 write
ssize_t write(int fd, const void *buf, size_t count);
write：就是把指定的缓冲区写到指定的文件里面。
fd 相当于FILE*类型，标定的一个文件，想往哪个文件写，就往哪个文件写。
buf 缓冲区起始地址
count 缓冲区大小
注意❗strlen不需要+1，strlen是计算字符串的有效内容。字符串\0是C语言的规定+1，这里是系调用接口，只需要写入有效字符串内容即可，不需要+1。

 1: myfile.c 
  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <sys/types.h>
  4 #include <sys/stat.h>
  5 #include <fcntl.h>
  6 #include<string.h>                                          
  7                                      
  8 int main()                           
  9 {                                      
 10   umask(0);//动态设置当前进程的权限掩码 11   int fd = open("log.txt",O_WRONLY | O_CREAT,0666);//给出文>    件权限0666                           
 12   if(fd < 0)                         
 13   {                                  
 14     perror("open");                  
 15     return 1;                        
 16   }                                  
 17                                             
 18   const char *message="hello linux file!\n";
 19   write(fd,message,strlen(message)); 
 20                                      
 21   close(fd);                         
 22   return 0;                          
 23 }