Brother Ali teaches you how to correctly understand the problem of standard IO buffer

According to the standard IO Buffers can be divided into three categories :

Do not cache type :

• Once there's data , Write data directly to a file

Row buffer type :

• Same as full buffer type

• encounter \n when , Write data to file

Full buffer type :

• When the program ends , Flush data to file

• When I meet fflush(), Flush data to file

• When the file is closed , Flush data to file

• When encountering read operation , Flush data to file

• When changing the type of buffer , Flush data to file

• When the buffer is full , Flush data to file

For standard output , The default is row buffering for standard errors , The default is not to cache. For ordinary files , The default is full buffer

#include <stdio.h>#include <unistd.h>int main(int argc, char const *argv[]){ // w+  Open the file read-write , If the file exists, empty the file data , If the file does not exist , Create file  FILE *fp = fopen(&quot;_a.txt&quot;, &quot;w+&quot;); //  Write data to file  fputs(&quot;123&quot;, fp); // Pause the program and don't let , Don't let the program end normally , Observe a.txt The contents of the document  pause(); return 0;}

We can see that the file is created , But there is nothing in the document . Let's analyze , At this time, we operate with ordinary files , This is the default full buffer , And called pause() function , The program did not end normally , So I can guess that the content at the moment is in the buffer , Not flushed into the document . If we put pause() Annotate , In the execution of the program , We can see that the data we want to write appears in _a.txt In file . This is also the first case of full buffer type , When the program ends , Read data into a file .

Next, let's take a look at this code :

#include <stdio.h>#include <unistd.h>int main(int argc, char const *argv[]){ FILE *fp = fopen(&quot;_a.txt&quot;, &quot;w+&quot;); fputs(&quot;123&quot;, fp); fflush(fp); pause(); return 0;}

To confirm the second case, we directly use the flushing function fflush(), You can see that the data is successfully read into the file .

The third case , stay fput Functions and pause In the middle of the function , call fclose(), Close file .

#include <stdio.h>#include <unistd.h>int main(int argc, char const *argv[]){ FILE *fp = fopen(&quot;_a.txt&quot;, &quot;w+&quot;); fputs(&quot;123&quot;, fp); fclose(fp); pause(); return 0;}

The fourth situation , When encountering read operation , Flush data to file .

#include <stdio.h>#include <unistd.h>int main(int argc, char const *argv[]){ FILE *fp = fopen(&quot;_a.txt&quot;, &quot;w+&quot;); fputs(&quot;123&quot;, fp); fgetc(fp); pause(); return 0;}

Next let's see through setvbuf() Change the type of buffer , Then flush the buffer zone .

A brief introduction :setvbuf function

This picture is me in man Screenshots from the manual .

int setvbuf(FILE *stream, char *buffer, int mode, size_t size)stream --  This is pointing to  FILE  Object pointer , The  FILE  Object identifies an open stream .buffer --  This is the buffer allocated to the user . If set to  NULL, This function automatically allocates a buffer of the specified size .mode --  This specifies the mode of file buffering .

size -- This is the size of the buffer , In bytes .

Return value ： If it works , Then the function returns  0, Otherwise, a nonzero value is returned .

#include <stdio.h>#include <unistd.h>int main(int argc, char const *argv[]){ FILE *fp = fopen(&quot;_a.txt&quot;, &quot;w+&quot;); // setvbuf(fp, NULL, _IONBF, 0); fputs(&quot;123&quot;, fp); setvbuf(fp, NULL, _IONBF, 0); pause(); return 0;}

Our sentence here is setvbuf(fp, NULL, _IONBF, 0), The default full buffer for ordinary files , Convert to unbuffered , The data is shown in the file , So it conforms to our fifth theory . This is to highlight our fifth theory , So put the statement in fput After statement , Of course, if we are setvbuf(fp, NULL, _IONBF, 0) Write the same after fputs Statement or will setvbuf(fp, NULL, _IONBF, 0), Place to fopen The same effect will be achieved after the statement . However, the understanding of the second situation is different , The successful reading of data at this moment is not due to the conversion of buffer type , But because it is now defined as unbuffered , So the data is directly read into the file .

Here we might as well try to define one by ourselves 100 Bytes of buf buffer , And convert the buffer type to row cache before reading data , Observe whether it can pass \n To read the data into the file .( Flushing buffer ).

#include <stdio.h>#include <unistd.h>int main(int argc, char const *argv[]){ FILE *fp = fopen(&quot;_a.txt&quot;, &quot;w+&quot;); char buf[1024]; setvbuf(fp, buf, _IOLBF, 1024); // Here is the line buffer , If you want to flush the data into ordinary files , Pay attention to add \n fputs(&quot;123\n&quot;, fp); pause(); return 0;}

All in all , Data stuck in buffers is sometimes referred to as dirty data （dirty data）, The existence of dirty data means that the result of program operation is inconsistent with the real state of the file , If you exit the program without flushing these dirty data normally, it may cause data loss , We are using IO Pay attention to the buffer when operating on data

Link to the original text ：https://www.cnblogs.com/yuniyuyuan577/p/16528454.html