Linux_基础IO

先复习一下以前C语言的几个IO函数

1）fopen（ #include <stdio.h> ）

     1>函数原型：FILE *fopen(const char *path, const char *mode);  mode-->打开方式

     2>返回值：成功返回文件指针，失败返回NULL

2）fread.fwrite( #include <stdio.h>)

    1>函数原型：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);

                          nmemb-->要进行写入size字节的数据项的个数；

    2>返回值：返回成功读或写元素的数量

写个例子：

 #include <stdio.h>
 #include <stdlib.h>
 
 int main(void){
 FILE* fp = fopen("myfile","w"); //以写方式打开
 if(fp==NULL)
        perror("fopen"),exit(1);
 const char * str="hello world!\n";
 int count=3;
 while(count--){
        fwrite(str,strlen(str),1,fp);
 }
 fclose(fp);
  return 0;
 }

结果：打开myfile文件

fread举例：

 #include <stdio.h>
 #include <stdlib.h>
 
 int main(void){
 FILE* fp = fopen("myfile","r"); //以写方式打开
 if(fp==NULL)
        perror("fopen"),exit(1);
  char buf[1024];//读缓冲区
 memset(buf,0x00,sizeof(buf));
 while(1){
 size_t size=fread(buf,1,sizeof(buf),fp);
 if(size>0){   //读到元素的个数
        buf[size]=0;
        printf("%s \n",buf);
 }
 if(feof(fp)) //EOF为文件结尾，读到文件结尾退出
        break;
 }
 
  fclose(fp);
  return 0;
 }

结果：

    3)fclose( #include <stdio.h>)--->关闭文件

        1>函数原型：int fclose(FILE *fp);

        2>返回值： Upon  successful  completion  0  is returned.  Otherwise, EOF is returned and errno is set to indicate the error.

        3>注意：打开文件要记得关闭，不然容易发生内存泄漏。

一.文件描述符

1）文件描述符来源

当我们打开一个文件时，操作系统在内存中要创建出一个数据结构来保存文件的相关信息。从而有了file结构体，表示已经打开的文件对象，而进程在调用open时，需要让文件和进程关联起来，每个进程有一个文件指针file *，指向一张表files_struct，该表包含一个指针数组，每个元素都是一个打开文件的指针。在指针数组中，每个元素的编号就是文件描述符。所以：文件描述符就是从0开始的正整数，本质上就是数组的下标，所以只要得到相应的文件描述符，就能找到对应的文件。

2）文件描述符的分配规则

  在说文件描述符分配之前，先说一下3个输入输出流

    1>stdin:标准输入

    2>stdout：标准输出

    3>stderr：标准错误输出

操作系统默认打开的3个缺省文件描述符，分别为0.1.2，这3个流的类型都是FILE*（文件指针）

先看一个例子

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 int main(void){
 int fd=open("myfile",O_RDONLY);
 if(fd<0){
        perror("open");
        exit(1);
 }
 printf("fd:%d\n",fd);
 close(fd);
 return 0;
 }

运行结果：

可以看出，系统为myfile分配的文件描述符为3，所以一般情况下自己创建的文件，文件描述符从3开始。

举个例子：

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 int main(void){
 close(0); //关闭默认打开的0号文件描述符
 
 int fd=open("myfile",O_RDONLY);
 if(fd<0){
        perror("open");
        exit(1);
 }
 printf("fd:%d\n",fd);
 close(fd);
 return 0;
 }

运行结果:

手动关闭默认的0号文件描述符，系统自动为你分配第一个没有被使用的最小的文件描述符，作为新的文件描述符。

叮-->文件重命名命令： mv 原文件名 新文件名

二. 输出重定向

此次关闭1号（stdout）文件描述符

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 int main(void){
 close(1); //关闭stdout文件描述符
 int fd=open("myfile",O_WRONLY|O_CREAT);
 if(fd == -1)perror("open"),exit(1);
 printf("fd:%d\n",fd);
 printf("end");
 fflush(stdout);
 close(fd);
 return 0;
 }

结果：

本应该输出在屏幕上的结果，输出到了myfile文件中，且myfile的文件描述符为1，这个现象叫做输出重定向。

造成这种现象是因为printf本应往stdout文件输出，但1号文件被关闭，且重定向到myfile文件上，但printf仍向1号文件输出结果，所以最后输出到了myfile中。

三.API

1）open

    1>头文件：  #include <sys/types.h> 和 #include <sys/stat.h> 和  #include <fcntl.h>

    2>函数原型：int open(const char *pathname, int flags);

                        int open(const char *pathname, int flags, mode_t mode); mode-->权限

    3>参数：pathman-->要打开或创建的文件名

                 flags-->打开的方式，用几个常量打开时中间加‘|’，几种选项

                                O_RDONLY:只读打开

                                O_WRONLY:只写打开

                                O_RDWR:读，写打开

                                       以上三个必有且只有一个

                                O_CREAT:若文件不存在则创建，创建时需写入访问权限（mode）

                                O_APPEND:追加写入

    4>返回值：成功返回打开的文件描述符，失败返回-1

    5>注意：以上两种具体使用哪个看是否需要创建文件，需要使用第二个并加上访问权限

2）close

    1>头文件： #include <unistd.h>

    2>函数原型：int close(int fd);

    3>参数：fd-->要关闭的文件描述符

    4>返回值：成功返回0，失败返回-1

3）write

    1>头文件：#include <unistd.h>

    2>函数原型： ssize_t write(int fd, const void *buf, size_t count);

    3>参数：fd-->要写入文件的文件描述符，buf-->要写入文件数据的地址，count-->数据的大小

    4>返回值：成功返回被写入字节数，失败返回-1

举例：

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 int main(void){
        const char * msg0="This is printf\n";
        const char * msg1="This is fwrite\n";
        const char * msg2="This is write\n";
 
        printf("%s",msg0);
        fwrite(msg1,strlen(msg1),1,stdout);
        write(1,msg2,strlen(msg2));
 
        fork();
 return 0;
 
 }

运行结果：

当将可执行文件重定向到另一个自己创建的文件中是，结果不同。

write只输出了一次，原因：printf和fwrite自带缓冲区，write没有缓冲区。

当写入文件后，缓冲方式由行缓冲变成了全缓冲，所以放在缓冲区的数据不会被立刻刷新，进程结束统一刷新缓冲区，写入文件中，但fork之后会发生写时拷贝，父进程准备刷新的时候，子进程也有了同样的一份数据，从而产生两份，write没有变化，说明write没有缓冲。

4）read

    1>头文件：#include <unistd.h>

    2>函数原型：ssize_t read(int fd, void *buf, size_t count);

    3>参数：fd-->要写入文件的文件描述符，buf-->准备装数据的地方，count-->每次读数据的字节数

    4>返回值：成功返回读取的字节数，失败返回-1 

举例：

#include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 int main(void){
 int fd =open("myfile",O_RDONLY);
 if(fd ==-1) perror("open"),exit(1);
 
 char  buf[1024];
 memset(buf,0x00,sizeof(buf));
 while(1){
 ssize_t size =read(fd,buf,3);  //每次读取3个字节，直到读完
 if(size<0) perror("size"),exit(1);
 if(size>0){
        printf("%s",buf);
 }
 else   //size=0,表示读到EOF文件结束
        break;
 }
 fflush(stdout);
 close (fd);
 return 0;
 

结果：

叮-->刷新缓冲区的方式

1.缓冲区满 2.\n 或\r3.一些输入函数：exit；return 0；