Fgets and fputs, fread and fwrite, fscanf and fprintf

String read/write functions fgets and fputs

1. The fgets function of the string reading function reads a string from a specified file to a character array. The function is called in the form of fgets (character array name, n, file pointer );
N is a positive integer. Indicates that the number of strings read from the file cannot exceed
N-1 characters. Add the end string sign '\ 0' after the last character '. For example, fgets (STR, N, FP); reads n-1 characters from the file indicated by FP and sends
Str.

[Example 10.4] Read a 10-character string from the e10_1.c file.

# Include <stdio. h>
Main ()
{
File * FP;
Char STR [11];
If (FP = fopen ("e10_1.c", "RT") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Fgets (STR, 11, FP );
Printf ("% s", STR );
Fclose (FP );
}

In this example, a string array of 11 characters is defined. After the e101.c file is opened in the text file mode, 10 characters are read from it and sent to the STR array, add '\ 0' to the last cell of the array, and then display the output STR array on the screen. The output 10 characters are the first 10 characters in the sample 10.1 program.

Fgets functions are described as follows:

1. If a linefeed or EOF is encountered before reading n-1 characters, the reading is complete.

2. The fgets function also has a return value, whose return value is the first address of the character array.

Ii. Write the string function fputs

The fputs function is used to write a string to a specified file. The call form is fputs (string, file pointer). The string can be a String constant or a character array name, or pointer variable, for example:

Fputs ("ABCD", FP );

The meaning is to write the string "ABCD" into the file specified by FP. [Example 10.5] append a string to the string created in example 10.2.

# Include <stdio. h>
Main ()
{
File * FP;
Char CH, St [20];
If (FP = fopen ("string", "At +") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Printf ("input a string: \ n ");
Scanf ("% s", St );
Fputs (St, FP );
Rewind (FP );
Ch = fgetc (FP );
While (Ch! = EOF)
{
Putchar (CH );
Ch = fgetc (FP );
}
Printf ("\ n ");
Fclose (FP );
}

In this example, a string must be added at the end of the string file. Therefore, the string file is opened in the append-read-write mode in line 2 of the program. Then input the string,
Use the fputs function to write the string to the file. In the 15 lines of the program, use the rewind function to move the internal position pointer of the file to the beginning of the file.
Then go to the loop to display all the content in the current file one by one.

Data Block read/write functions fread and fwrite

The C language also provides read/write functions for the entire data block. It can be used to read and write a group of data, such as an array element and a value of a structure variable. The call Method for reading data block functions is as follows:
Fread (buffer, size, Count, FP); write data block function calls are generally in the form:
Fwrite (buffer, size, Count, FP );
Buffer is a pointer. In the fread function, it indicates the first address to store the input data. In the fwrite function, it indicates the first address of the output data. Size
The number of bytes of the data block. Count indicates the number of data blocks to read and write. FP indicates the file pointer.

For example:

Fread (FA, FP); it means that four bytes (a real number) are read each time from the file indicated by FP and sent to the real array FA for five consecutive reads, read 5 real numbers into fa.

[Example 10.6] input two student data from the keyboard, write them into a file, and read the data of the two students on the screen.

# Include <stdio. h>
Struct Stu
{
Char name [10];
Int num;
Int age;
Char ADDR [15];
} Boya [2], boyb [2], * PP, * QQ;
Main ()
{
File * FP;
Char ch;
Int I;
Pp = Boya;
Qq = boyb;
If (FP = fopen ("stu_list", "WB +") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Printf ("\ ninput data \ n ");
For (I = 0; I <2; I ++, pp ++)
Scanf ("% S % d % s", PP-> name, & PP-> num, & PP-> Age, PP-> ADDR );
Pp = Boya;
Fwrite (PP, sizeof (struct Stu), 2, FP );
Rewind (FP );
Fread (QQ, sizeof (struct Stu), 2, FP );
Printf ("\ n \ nname \ tnumber age ADDR \ n ");
For (I = 0; I <2; I ++, QQ ++)
Printf ("% s \ t % 5d % 7D % s \ n", QQ-> name, QQ-> num, QQ-> Age, QQ-> ADDR );
Fclose (FP );
}

In this example, the program defines a structure Stu, which describes the two arrays Boya and
Boyb and two structure pointer variables PP and QQ. PP points to Boya, QQ points to boyb. The second line of the program opens the binary file "stu_list" in read/write mode, and enters two
After the data is generated, it is written into the file, and the internal position pointer of the file is moved to the beginning of the file. After reading two pieces of student data, it is displayed on the screen.

Formatting read/write functions fscanf and fprintf

The fscanf function and fprintf function are similar to the functions of the scanf and printf functions used earlier. They are both formatted read/write functions. The difference between the two is that fscanf
The read and write objects of functions and fprintf are not keyboard and display objects, but disk files. The call formats of these two functions are: fscanf (File pointer, Format String, input table column );
Fprintf (File pointer, Format String, output table column); for example:

Fscanf (FP, "% d % s", & I, S );
Fprintf (FP, "% d % C", J, CH );

The fscanf and fprintf functions can also be used to solve the problem in the case of 10.6. Shows the modified program in example 10.7.

[Example: 10.7]

# Include <stdio. h>
Struct Stu
{
Char name [10];
Int num;
Int age;
Char ADDR [15];
} Boya [2], boyb [2], * PP, * QQ;
Main ()
{
File * FP;
Char ch;
Int I;
Pp = Boya;
Qq = boyb;
If (FP = fopen ("stu_list", "WB +") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Printf ("\ ninput data \ n ");
For (I = 0; I <2; I ++, pp ++)
Scanf ("% S % d % s", PP-> name, & PP-> num, & PP-> Age, PP-> ADDR );
Pp = Boya;
For (I = 0; I <2; I ++, pp ++)
Fprintf (FP, "% S % d % s \ n", PP-> name, PP-> num, PP-> Age, PP->
ADDR );
Rewind (FP );
For (I = 0; I <2; I ++, QQ ++)
Fscanf (FP, "% S % d % s \ n", QQ-> name, & QQ-> num, & QQ-> Age, QQ-> ADDR );
Printf ("\ n \ nname \ tnumber age ADDR \ n ");
Qq = boyb;
For (I = 0; I <2; I ++, QQ ++)
Printf ("% s \ t % 5d % 7D % s \ n", QQ-> name, QQ-> num, QQ-> Age,
Qq-> ADDR );
Fclose (FP );
}

Compared with example 10.6, in this program, the fscanf and fprintf functions can read and write only one structural array element at a time. Therefore, they use loop statements to read and write all array elements. Note that the pointer variable PP, QQ, has changed their values cyclically, so they are re-assigned the first address of the array in line 25 and 32 of the program.

Random file read/write

The read and write methods for files are sequential read and write, that is, the read and write files can only start from the beginning, read and write data sequentially. However, in practice, it is often required that a specified part of the read-only file be written.
To solve this problem, the position pointer inside the file is moved to the location where the file needs to be read and written before reading and writing. This read and writing is called random read and write.
The key to achieving random read/write is to move the location pointer as required, which is called file location. There are two main functions used to locate and move the internal pointer of a file: rewind.
Function and fseek function.

The rewind function has been used multiple times before and is called in the form of rewind (File pointer). Its function is to move the position pointer inside the file to the beginning of the file. The following describes
Fseek function.

The fseek function is used to move the internal position pointer of a file. The call form is fseek (File pointer, displacement, starting point). The "file Pointer" points to the object to be moved.
"Displacement" indicates the number of bytes to be moved. The displacement is long, so that the file length is greater than 64 KB.
No error. When a constant is used to represent the displacement, the suffix "L" is required ". The "Starting Point" indicates where to start the calculation of the displacement. There are three defined starting points: the first part of the file, the current position, and the end of the file.

The representation is shown in Table 10.2.

Starting point represents a symbolic number.
── ─
First seek-set 0
Current location seek-cur 1
Seek-end 2 at the end of the file

For example:

Fseek (FP, 100l, 0); it means to move the position pointer to the first 100 bytes away from the file. It must be noted that the fseek function is generally used for binary files. In a text file
To convert, so the calculation location is often incorrect. The random read/write of the object is after the pointer is moved,
You can use any of the read and write functions described above to read and write. Generally, fread and fwrite functions are commonly used to read and write data blocks. The following example describes the random read/write operations of a file.

[Example 10.8] read the data of the second student in the student file Stu list.

# Include <stdio. h>
Struct Stu
{
Char name [10];
Int num;
Int age;
Char ADDR [15];
} Boy, * QQ;
Main ()
{
File * FP;
Char ch;
Int I = 1;
Qq = & boy;
If (FP = fopen ("stu_list", "rb") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Rewind (FP );
Fseek (FP, I * sizeof (struct Stu), 0 );
Fread (QQ, sizeof (struct Stu), 1, FP );
Printf ("\ n \ nname \ tnumber age ADDR \ n ");
Printf ("% s \ t % 5d % 7D % s \ n", QQ-> name, QQ-> num, QQ-> Age,
Qq-> ADDR );
}

The stu_list file has been created by the program in example 10.6. This program reads the data of the second student by random reading. The program defines the variable "boy" as the stu type, and "QQ" as the point to "boy ".
Pointer. Open the file by reading the binary file, and the program moves the file location pointer in line with 22nd. The I value is 1, which indicates moving an Stu type length from the file header,
The data that is then read is the data of the second student.

File Detection Functions

The following file detection functions are commonly used in C language.

1. File end detection function feof function call format: feof (File pointer );

Function: determines whether the object is at the end of the object. If the object ends, the return value is 1. Otherwise, the return value is 0.

Ii. file read/write error detection function ferror function call format: ferror (File pointer );

Function: checks whether an error occurs when a file is read or written using various input/output functions. If the return value of ferror is 0, it indicates no error; otherwise, it indicates an error.

3. Set the file error mark and file end sign to 0. clearerr function call format: clearerr (File pointer );

Function: This function is used to clear the error mark and end mark of a file so that they are 0 values.

C library file

C system provides rich system files, called library files. C library files are divided into two types: files with the extension of ". H", called header files,
We have used the preceding command multiple times. The ". H" file contains the constant definition,
Type Definition, macro definition, function prototype, and various compilation selection settings. Another type is the function library, which includes the target code of various functions for users to call in the program.
When a library function is called in a program, the ". H" file of the function prototype must be included before the function is called.

All database functions are provided in the appendix.

Alloc. h indicates memory management functions (such as allocation and release ).
Assert. h defines assert debugging macros.
BiOS. h describes the various functions that call the IBM-PC rom bios subroutine.
Conio. h indicates that each function of the I/O subprogram of the DOS console is called.
Ctype. h contains the name class information about character classification and conversion (such as isalpha and toascii ).
Dir. h contains the Directory and path structures, macro definitions, and functions.
Dos. h defines and describes some constants and functions called by msdos and 8086.
Erron. h defines the entrustment of the error code.
Fcntl. h defines the symbolic constant used to connect to the Open Library subroutine.
Float. h contains some parameters and functions related to floating point operations.
Graphics. h describes various functions related to graphic functions, constant definitions of graphic error codes, various color values of different drivers, and some special structures used by functions.
Io. h contains the structure and description of low-level I/O subprograms.
Limit. h contains environment parameters, compilation time limits, number ranges, and other information.
Math. h describes the mathematical operation functions, and defines the huge Val macro, which describes the special structures used by matherr and matherr subprograms.
Mem. h indicates some memory operation functions (most of them are also described in string. h ).
Process. h describes the various functions of process management, spawn... And exec... Function structure description.
Setjmp. h defines the JMP Buf types used by longjmp and setjmp functions.
Share. h defines the parameters of the file sharing function.
Signal. h defines the SIG [ZZ (Z] [zz)] ign and SIG [ZZ (Z] [zz)] DFL constants, indicating the rajse and signal functions.
Stdarg. h defines the macro of the read function parameter table. (Such as vprintf and vscscarf functions ).
Stddef. h defines some common data types and macros.
Stdio. h defines the standard and extended types and macros defined by kernighan and Ritchie in UNIX System V. Standard I/O predefined streams: stdin, stdout, and stderr are also defined to describe the I/O Stream subprograms.
Stdlib. h describes some common subprograms, such as conversion subprograms and search/sort subprograms.
String. h describes some string operations and memory operation functions.
Sys \ Stat. h defines some symbolic constants used to open and create files.
Sys \ types. h describes the ftime function and timeb structure.
Sys \ time. h defines the time type time [ZZ (Z] [zz)] T.
Time. h defines the structure of the time conversion subprograms asctime, localtime, and gmtime, the types used by ctime, difftime, gmtime, localtime, and stime, and provides prototype of these functions.
Value. h defines some important constants, including those dependent on machine hardware and which are described for compatibility with UNIX System V, including floating point and double precision value ranges.