C Language Empty Input buffer N method comparison (GO)

There are several basic input functions in the C language:

//Get character SeriesintFGETC (FILE *stream);intGETC (FILE *stream);intGetCharvoid);//Get Row SeriesChar*fgets (Char* Restrict S,intN, FILE *restrict stream);Char*gets (Char*s);//may cause overflow, replace it with Fgets. //Format Input SeriesintFSCANF (FILE * Restrict Stream,Const Char*restrict format, ...);intscanfConst Char*restrict format, ...);intsscanfConst Char* Restrict Str,Const Char* Restrict format, ...);

This only discusses the use of input functions in the case of standard input (stdin). Throughout the above input functions,

• Gets the first three functions of the character series fgetc, Getc, GetChar. In GetChar, for example, when the stdin buffer is empty, wait for input until the return-to-line function returns. If the stdin buffer is not empty, GetChar returns directly. GetChar returns a character from the buffer and converts it to an int, returning this int value.

MINGW 4.4.3 File Structure source code :

 typedef struct   _iobuf{ char  * _PTR; //     points to the current buffer read position  int  _cnt; //        char  * _base;     int   _flag;     int   _file;     int   _charbuf;     int   _bufsiz;  char  * _tmpfname;} FILE;  

Each compiler implementation may be different, and getting the character series functions here only uses _ptr and _cnt.

MINGW 4.4.3 in GetChar () implementation :

int __cdecl __mingw_nothrow getchar (void) {  return0)    ?  (intchar) *stdin->_ptr++    : _filbuf (stdin);}

Where stdin is the file pointer type, in MinGW 4.4.3, getc () and GetChar () are implemented as inline functions, and fgetc () is implemented as functions. By the way, the C99 standard has been added to the support of the inline function.

• Gets the fgets and gets of the row series , where the Get function is not recommended or discussed, because gets cannot determine the buffer size and often results in overflow conditions. For the fgets function, Fgets returns each time you enter a carriage return. When Fgets returns successfully, the data in the input buffer is copied into the space pointed to by the first argument, with the line feed character ' \ n '. If the input data exceeds the buffer length, fgets intercepts the data to the first n-1 (n is the second parameter of Fgets, points to the length of the space for the first argument), and then adds ' \ n ' at the end. So the fgets is safe. Usually with fgets (buf, Buf_len, stdin), instead of gets (BUF);.
• Formatting input from a file stream in a formatted input series is not fscanf. Commonly used or scanf, formatted input series function to enter data (depending on the function may be the standard input may also be a string input, such as: sscanf) before the white space characters (spaces, tabs, line breaks) until the non-whitespace characters are encountered, It then attempts to parse non-whitespace characters and subsequent characters according to the format parameters. The series function returns the number of variables that successfully resolved the assignment, and returns EOF if a file tail or error is encountered.

================= Split Line =================

Referring to buffers, you have to mention setbuf and setvbuf two buffer set functions, which are declared as follows:

void Char * restrict buf); int Char int mode, size_t size);

The mode parameters of the setvbuf are:

• _IOFBF (full buffering): Buffers are read into data when empty, and data is written to the stream when the buffer is full.
• _IOLBF (Row buffer): reads a row of data from the stream or writes data to the stream each time. such as:stdio,stdout
• _IONBF (unbuffered): reads data directly from the stream, or writes data directly to the stream without a buffer. such as:stderr

setbuf (Stream, buf); in:

• BUF = = NULL: equivalent to (void) setvbuf (stream, NULL, _IONBF, 0);
• BUF points to a buffer of length bufsiz : equivalent to (void) setvbuf (stream, buf, _IOFBF, Bufsiz);

Note:bufsiz macros are defined in stdio.h.

Here also to mention the legendary setbuf of the Classic error , in the "C Traps and defects" mentioned:

int Main () {    int  C;     Char Buf[bufsiz];    Setbuf (STDOUT,BUF);      while ((c = GetChar ())! = EOF)        Putchar (c)        ; return 0 ;}

The problem is this: the C run-time library must clean up before the program returns control to the operating system, partly by refreshing the output buffer, but at this point the main function is finished, and the BUF buffer scope is in the main function, when the BUF character array is released. Causes the output to be garbled.

Solution: You can set buf to static, or global variables, or call malloc to dynamically request memory.

================= Split Line =================

Here's a look at several popular buffer emptying methods:

• Fflush (stdin);

By the C99 standard document:

If stream points to an output stream or a update stream in which the most recent

Operation is not input, the Fflush function causes any unwritten data for that stream

To being delivered to the host environment to being written to the Le; Otherwise, the behavior is

unde?ned.

It can be seen that the behavior of the input stream as a parameter is not defined by Fflush . However, it is defined by Fflush on MSDN:

Can see Fflush (stdin) on the VC or effective! Fflush (stdin) is not recommended to flush the input buffers, since each compiler does not implement the undefined behavior of fflush.

• Setbuf (stdin, NULL);

By the introduction of the front facing setbuf function, it can be learned that setbuf (stdin, NULL), is to make the stdin input stream from the default buffer to no buffer . There is no buffer, of course, the buffer data residue problem will be resolved. But that's not what we want.

• scanf ("%*[^\n]"); formula (referred to in the second edition of the Modern method of C language programming)

This uses the "*" in the scanf formatter, which is the assignment mask; "%[^ collection", which matches any sequence of characters that are not in the collection. This also brings up a problem where the newline character ' \ n ' in the buffer will stay, requiring additional action to discard the newline character separately.

• Classic style

int C;

while ((c = GetChar ())! = ' \ n ' && c! = EOF);

Known by the code, keep using GetChar () to get the characters in the buffer until the character C is the line break ' \ n ' or the end of file is EOF. This method can perfectly erase the input buffer and is portable.

Http://www.cnblogs.com/codingmylife/archive/2010/04/18/1714954.html

C Language Empty Input buffer N method comparison (GO)