[Linux]----文件操作(重定向+缓冲区)

文章目录

• ​​前言​​
• ​​一、重定向​​

• ​​具体操作​​

• ​​dup2​​

• ​​二、关于缓冲区的理解​​

• ​​1. 什么是缓冲区​​
• ​​2. 为什么要有缓冲区​​
• ​​3. 缓冲区在哪里​​

• ​​刷新策略机制​​
• ​​如果在刷新之前，关闭了fd会有什么问题？​​
• ​​FLIE内部的封装​​

• ​​特殊情况​​
• ​​模拟实现封装C标准库​​
• ​​标准输出和标准错误​​

• ​​总结​​

前言

本节继续基于上节文件描述符继续往下拓展，讲一讲关于文件操作的重定向和缓冲区。

​​正文开始！​​

首先来基于上节课的问题

#include<stdio.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
int main()
{
    close(1);
    int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
    fprintf(stdout,"打开文件成功,fd=%d",fd);
    //fflush(stdout);
    close(fd);
}

我们发现既没有往显示器打印，也没有往文件里面打印！

然后我们将fflush()这一行代码取消注释后

我们可以发现打印内容到了文件中了。至于为什么要用fflush()函数，需要了解到缓冲区的内容，接下来带大家理解！

那我有一个问题了？为什么不往显示器去打印，而是打印在了文件中呢？？？

一、重定向

如果我们要进行重定向，上层只认0,1,2,3这样的fd，我们可以在OS内部，通过一定的方式调整数组的特定下标内容够(指向)，我们就可以完成重定向操作！

对于上图，我们进行重定向后，fprintf并不知道1号文件描述符指向了"log.txt"文件，而继续向1号文件描述符打印东西。

具体操作

上面的一堆的数据，都是内核数据结构。只有谁有权限呢？？？

必定是操作系统(OS)---->必定提供系统结构！

dup2

相比于dup，dup2更复杂一些，我们今天主要使用多duo2进行重定向操作！

在这里我们首先进行输出重定向

stdout–>1 log.txt–>fd

1. 那么对于dup2()接口，谁是谁的一份拷贝呢？
   对于上面框起来的内容翻译就是newfd是oldfd的一份拷贝，就是把oldfd的内容放置newfd里面。最后只剩oldfd了！！！
2. 参数怎么传呢？？
   我们要输出重定向到文件中，即就是stdout的输出到文件中，即就是1号文件描述符的内容要指向新创建文件的描述符。

dup2(fd,1);

int main()
{

    int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
    dup2(fd,1);
    fprintf(stdout,"打开文件成功,fd=%d",fd);

    fflush(stdout);
    close(fd);
}

输入重定向

int main()
{

    int fd=open("log.txt",O_RDONLY);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
    dup2(fd,0);
    char line[64];
    while(fgets(line,sizeof(line),stdin)!=NULL)
    {
        printf(line);
    }

    fflush(stdout);
    close(fd);
}

二、关于缓冲区的理解

1. 什么是缓冲区

• 缓冲区的本质:就是一段内存。

2. 为什么要有缓冲区

• 解放使用缓冲区的进程时间
• 缓冲区的存在可以集中处理数据刷新，减少IO的次数，从而达到提高整机的效率的目的！

3. 缓冲区在哪里

我来写一份代码带大家验证一下！

int main()
{
    printf("hello printf\n");   //stdout-->1
    const char* msg="hello write\n";
    write(1,msg,strlen(msg));
}

去掉’'以后

int main()
{
    printf("hello printf");   //stdout-->1
    const char* msg="hello write";
    write(1,msg,strlen(msg));
}

printf没有立即刷新的原因，是因为有缓冲区的存在

write可是立即刷新的！

所以我们根据以上的实验现象我们可以发现stdout必定封装了write！

那么这个缓冲区不在哪里？？ ---->一定不在wirte内部！

所以我们曾经讨论的缓冲区，不是内核级别的！

所以这个缓冲区在哪里？？？—>只能是C语言提供的！！！(语言级别的缓冲区)

因为printf是往stdout中打印，stdout—>FILE—>struct—>封装很多的属性---->fd—>该FILE对于的语言级别的缓冲区！

刷新策略机制

int main()
{
    printf("hello printf");//stdout->1->封装了write
    fprintf(stdout,"hello fprintf");
    fputs("hello fputs",stdout);

    const char* msg="hello write";
    write(1,msg,strlen(msg));

    return 0;
}

什么时候刷新？

• 无缓冲(立即刷新)
• 行缓冲(逐行刷新)—>显示器文件
• 全缓冲(缓冲区满，刷新)—>块设备对应的文件(磁盘文件)

无缓冲的特殊情况
a.进程退出
b.用户强制刷新

如果在刷新之前，关闭了fd会有什么问题？

int main()
{
    printf("hello printf");//stdout->1->封装了write
    fprintf(stdout,"hello fprintf");
    fputs("hello fputs",stdout);

    const char* msg="hello write";
    write(1,msg,strlen(msg));
    close(1);
    //close(stdout->_fileno);//和上面close(1)效果相同
    return 0;
}

一开始我们只是把数据写入到FILE结构体的缓冲区，然后你把文件描述符给关了，当然就写不进文件中了！！！

现在我们就能来理解一开始我们抛出的问题了！！！

既然缓冲区在FILE内部，在C语言中，而我们每一次打开一个文件，都要有一个FILE*会返回！！
那就意味着，每一个文件都有一个fd和属于他自己的语言级别的缓冲区！！！

FLIE内部的封装

在/usr/include/libio.h
struct _IO_FILE {
 int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
 //缓冲区相关
 /* The following pointers correspond to the C++ streambuf protocol. */
 /* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
 char* _IO_read_ptr; /* Current read pointer */
 char* _IO_read_end; /* End of get area. */
 char* _IO_read_base; /* Start of putback+get area. */
 char* _IO_write_base; /* Start of put area. */

特殊情况

int main()
{
    const char* str1="hello printf\n";
    const char* str2="hello fprintf\n";
    const char* str3="hello fputs\n";
    const char* str4="hello write\n";
    
    //C库函数
    printf(str1);
    fprintf(stdout,str2);
    fputs(str3,stdout);
    
    //系统接口
    write(1,str4,strlen(str4));
    
    //是调用完了上面的代码，才执行的fork
    fork();
}

对代码去掉’\n’

int main()
{
    const char* str1="hello printf";
    const char* str2="hello fprintf";
    const char* str3="hello fputs";
    const char* str4="hello write";
    
    //C库函数
    printf(str1);
    fprintf(stdout,str2);
    fputs(str3,stdout);
    
    //系统接口
    write(1,str4,strlen(str4));
    
    //是调用完了上面的代码，才执行的fork
    fork();
}

1. 刷新的本质，就是把缓冲区的数据写到OS内部，清空缓冲区！
2. 缓冲区是自己的FILE内部维护的，属于父进程
3. 子进程也继承了父进程的缓冲区，也就打印了父进程缓冲区的内容！

模拟实现封装C标准库

只封装了C语言库的一部分！

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

#define NUM 1024

#define NONE_FLUSH 0x0
#define LINE_FLUSH 0x1
#define FULL_FLUSH 0x2

typedef struct _MyFILE
{
    int _fileno;
    char buffer[NUM];
    int _end;
    int _flags;//fflush method
}MyFILE;

MyFILE* my_fopen(const char* filename,const char* method)
{
    assert(filename&&method);
    int flags=O_RDONLY;

    if(strcmp(method,"r")==0)
    {}
    else if(strcmp(method,"r+")==0)
    {} 
    else if(strcmp(method,"w")==0)
    {
        flags=O_WRONLY|O_CREAT|O_TRUNC;

    }
    else if(strcmp(method,"w+")==0)
    {}
    else if(strcmp(method,"a")==0)
    {
        flags=O_WRONLY|O_CREAT|O_APPEND;
    }
    else if(strcmp(method,"a+")==0)
    {}
    
    int fileno=open(filename,flags,0666);
    if(fileno<0)  return NULL;
    MyFILE* fp=(MyFILE*)malloc(sizeof(MyFILE));
    if(fp==NULL)
    {
        return NULL;
    }
    memset(fp,0,sizeof(MyFILE));
    fp->_fileno=fileno;
    fp->_flags|=LINE_FLUSH;
    fp->_end=0;
    return fp;
}

void my_fflush(MyFILE* fp)
{
    assert(fp);
    if(fp->_end>0)
    {
        write(fp->_fileno,fp->buffer,fp->_end);
        fp->_end=0;
        syncfs(fp->_fileno);
    }
    
}


void my_fwrite(MyFILE* fp,const char* start,int len)
{
    assert(fp&&start&&len>0);

    strncpy(fp->buffer+fp->_end,start,len);//将数据写入到缓冲区了
    fp->_end+=len;

    if(fp->_flags&NONE_FLUSH)
    {

    }
    else if(fp->_flags&LINE_FLUSH)
    {
        if(fp->_end>0&&fp->buffer[fp->_end-1]=='\n')
        {
            //仅仅是写入到内核中
            write(fp->_fileno,fp->buffer,fp->_end);
            fp->_end=0;
        }
    }
    else if(fp->_flags&FULL_FLUSH)
    {

    }
}

void my_close(MyFILE* fp)
{
    my_fflush(fp);
    close(fp->_fileno);
    free(fp);
}

int main()
{
    MyFILE* fp=my_fopen("log.txt","w");
    if(fp==NULL)
    {
        printf("my_fopen fail\n");
        return 1;
    }
    const char* s="hello my 111\n";
    my_fwrite(fp,s,strlen(s));
    
    printf("消息立即刷新");
    sleep(3);


    const char* ss="hello my 222";
    my_fwrite(fp,ss,strlen(ss));
    sleep(3);
    printf("写入了一个不满足条件的字符串\n");


    const char* sss="hello my 333";
    my_fwrite(fp,sss,strlen(sss));
    sleep(3);
    printf("写入了一个不满足条件的字符串\n");


    const char* ssss="end\n";
    my_fwrite(fp,ssss,strlen(ssss));
    sleep(3);
    printf("写入了一个满足条件的字符串\n");

    const char* sssss="aaaaaaaaaa";
    my_fwrite(fp,sssss,strlen(sssss));
    printf("写入了一个不满足条件的字符串\n");
    
    sleep(1);
    my_fflush(fp);
    sleep(3);

    my_close(fp);
    return 0;
}

标准输出和标准错误

#include<iostream>
#include<cstdio>

int main()
{
    //stdout
    printf("hello printf 1\n");
    fprintf(stdout,"hello fprintf 1\n");
    fputs("hello puts 1\n",stdout);

    //stderr
    fprintf(stderr,"hello fprintf 2\n");
    fputs("hello puts 2\n",stderr);
    perror("hello perror 2");

    //cout
    std::cout<<"hello cout 1"<<std::endl;

    //cerr
    std::cerr<<"hello cerr 2"<<std::endl;

}

我们发现打1的都不见了

向stdout里面打的都重定向到log.txt文件中，stderr继续打印到显示器。

./a.out >stdout.txt 2>stderr.txt

一条语句进行两次重定向

那么意义在哪里呢？

可以区分那些是程序日常输出，那些是错误！

我们也可以将上面的两个文件打印在一个文件

./a.out >all.txt 2>&1

总结

（本章完！）
下节课我们基于重定义的学习来完善我们之前写的myshell！！！