Introduction to C language beginners lecture 16th lecture documents (1)

Http://www.programfan.com/article/showarticle.asp? Id = 2697

The so-called "file" refers to an ordered set of related data. This dataset has a name called a file name. In fact, we have used files many times in the previous chapter, such as source program files, target files, executable files, library files (header files), and so on. Files usually reside on external media (such as disks) and are only transferred to the memory during use. Files can be classified from different angles. From the user's perspective, files can be divided into common files and device files.

A common file is an ordered dataset that resides on a disk or other external media. It can be a source file, a target file, or an executable program. It can also be a set of raw data to be input and processed, or a set of output results. Source files, target files, and executable programs can be called program files, and input and output data can be called data files.

A device file is an external device associated with a host, such as a display, printer, or keyboard. In the operating system, external devices are also managed as files, and their input and output are equivalent to reading and writing disk files. Generally, a display is defined as a standard output file. Generally, information displayed on the screen is output to the standard output file. For example, the previously used printf function putchar is the output type. The keyboard is usually designated as a standard input file. inputting on the keyboard means inputting data from the standard input file. Scanf and getchar functions belong to this type of input.

From the file encoding method, files can be divided into two types: ASCII code files and binary code files.

An ASCII file is also called a text file. When a file is stored on a disk, each character corresponds to one byte and is used to store the corresponding ASCII code. For example, the storage format of hundreds of thousands is:
ASC: 00110101 00110110 00110111 00111000
↓
Decimal code: 5 6 7 8 occupies 4 bytes in total. The ASCII code file can be displayed by characters on the screen. For example, the source code file is an ASCII file, and the doscommand type can be used to display the file content. Because it is displayed by characters, you can read the file content.

Binary files are stored in binary encoding. For example, the storage format of hundreds of thousands is: 5678 00010110 occupies only two bytes. Although a binary file can be displayed on the screen, its content cannot be understood. When processing these files, the C system treats them as byte streams and does not differentiate the types. The start and end of the input and output streams are only controlled by the program, not by physical symbols (such as carriage returns. Therefore, this type of file is also called a "streaming File ".

This chapter describes how to open, close, read, write, and locate streaming files. The file Pointer Points to a file using a pointer variable in C language. This pointer is called a file pointer. The file pointer can be used to perform various operations on the files it refers. The definition description file pointer is generally in the format of file * pointer variable identifier, where file should be capitalized, which is actually a structure defined by the system, this structure contains the file name, File status, and current file location. You do not have to worry about the details of the file structure when writing the source program. For example, file * FP indicates that FP is a pointer variable pointing to the file structure. You can use FP to find the structure variable that stores the information of a file, and then find the file according to the information provided by the structure variable, perform operations on files. In general, FP is also called a pointer to a file. Open and Close a file before performing read/write operations. Opening a file is actually about creating information about the file and directing the file pointer to the file for other operations. If the file is closed, the connection between the pointer and the file is closed, and operations on the file are prohibited.

In C, file operations are performed by library functions. This chapter describes the main file operation functions.

File opening function fopen

The fopen function is used to open a file. The call is generally in the form of: file pointer name = fopen (file name, using the file method) where, "file pointer name" must be a pointer variable described as file type, and "file name" must be the name of the opened file. "File Usage" refers to the file type and operation requirements. The "file name" is a String constant or a string array. For example:

File * FP;
Fp = ("file a", "R ");

It means to open file a in the current directory, only allow "read" operations, and direct FP to the file.

Another example:

File * fphzk
Fphzk = ("C: // hzk16'," rb ")

It means to open the file hzk16 under the root directory of drive C, which is a binary file and only allows read operations in binary mode. The first of the two Backslash "//" represents the escape character, and the second represents the root directory. There are 12 methods to use files. Their symbols and meanings are given below.

File Usage
"RT" only opens a text file and only supports reading data.
"WT" only writes to open or create a text file, only data can be written
Append "at" to open a text file and write data at the end of the file.
"Rb" is used to open a binary file and only read data.
"WB" only writes to open or create a binary file, only data can be written
Append "AB" to open a binary file and write data at the end of the file.
"RT +" reads and writes to open a text file, allowing reading and writing
"WT +" reads and writes to open or create a text file, allowing reading and writing
"At +" to open a text file, allow reading, or append data to the end of the file
"RB +" reads and writes a binary file, allowing reading and writing
"WB +" to open or create a binary file and allow reading and writing
"AB +" reads and writes to open a binary file, allowing reading or appending data at the end of the file

The usage of files is described as follows:

1. The file is comprised of R, W, A, T, B, and +. The meanings of each character are as follows:

R (read): Read
W (write): Write
A (append): append
T (text): Text File, can be omitted without writing
B (banary): Binary File
+: Read and Write

2. When you use "R" to open a file, the file must already exist and can only be read from the file.

3. A file opened with "W" can only be written to this file. If the opened file does not exist, the file is created with the specified file name. If the opened file already exists, delete the file and create a new file.

4. to append new information to an existing file, you can only open the file in "A" mode. However, this file must exist at this time; otherwise, an error will occur.

5. If an error occurs when opening a file, fopen returns a null pointer value. In the program, this information can be used to determine whether to complete the file opening and handle it accordingly. Therefore, the following sections are commonly used to open files:

If (FP = fopen ("C: // hzk16", "rb") = NULL)
{
Printf ("/nerror on Open C: // hzk16 file! ");
Getch ();
Exit (1 );
}

The meaning of this program is that if the returned pointer is null, it indicates that the hzk16 file under the root directory of the C drive cannot be opened, the message "error on Open C:/hzk16file!" is displayed !", The next line of getch () is used to input a character from the keyboard, but is not displayed on the screen. Here, the role of this row is to wait. The program continues to be executed only when you press one key from the keyboard. Therefore, you can use this wait time to read the error message. Press the key and execute exit (1) to exit the program.

6. when reading a text file into the memory, you need to convert the ASCII code into a binary code. When writing the file into a disk as text, you also need to convert the binary code into an ascii code, therefore, it takes a lot of time to read and write text files. This conversion does not exist for reading/writing binary files.

7. The standard input file (keyboard), standard output file (Display), and standard error output (error information) are opened by the system and can be used directly. Once the fclose file function is used, the application closes the file function to avoid errors such as file data loss.

Fclose Function

The call method is fclose (File pointer). For example:

Fclose (FP); when the file close operation is completed normally, the return value of the fclose function is 0. If a non-zero value is returned, an error occurs. File read/write is the most common file operation.

The C language provides a variety of functions for reading and writing files:

· Character read/write functions: fgetc and fputc

· String read/write functions: fgets and fputs

· Data block read/write functions: freed and fwrite

· Formatted read/write functions: fscanf and fprinf

The following sections describe them respectively. The above functions must contain the header file stdio. h. The character read/write functions fgetc and fputc are read/write functions in bytes. One character can be read from or written to a file each time.

I. Read character function fgetc

The fgetc function is used to read a character from a specified file. The function is called in the form of: character variable = fgetc (File pointer); for example: CH = fgetc (FP ); it means reading a character from the open file FP and sending it to Ch.

The usage of the fgetc function is described as follows:

1. In the fgetc function call, the read file must be opened in read or read/write mode.

2. The result of reading a character can also be not assigned to the character variable, for example, fgetc (FP). However, the read characters cannot be saved.

3. There is a position pointer inside the file. It is used to point to the current read/write bytes of the file. When a file is opened, the pointer always points to the first byte of the file. After the fgetc function is used, the position pointer moves one byte backward. Therefore, you can use the fgetc Function Multiple times to read multiple characters. Note that the file pointer is not the same as the position pointer inside the file. The file Pointer Points to the entire file and must be defined in the program. As long as no value is assigned again, the file pointer value remains unchanged. The position pointer inside the file is used to indicate the current read/write position inside the file. Every read/write time, the pointer moves backward. It does not need to be defined in the program, but is automatically set by the system.

[Example 10.1] Read the file e10-1.c and output on the screen.

# Include <stdio. h>
Main ()
{
File * FP;
Char ch;
If (FP = fopen ("e10_1.c", "RT") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Ch = fgetc (FP );
While (Ch! = EOF)
{
Putchar (CH );
Ch = fgetc (FP );
}
Fclose (FP );
}

The function of this program is to read characters from files one by one and display them on the screen. The program defines the file pointer FP, opens the file "e10_1.c" as a read text file, and points FP to the file. If an error occurs while opening the file, a prompt is displayed and the program is exited. The program first reads a character in line 3 and then enters the loop. As long as the read character is not the end mark of the file (each file has an end mark EOF), the character is displayed on the screen, read the next character. Each time a file is read, the position pointer inside the file moves a character backward. When the file ends, the Pointer Points to EOF. Execute this program to display the entire file.

Ii. Write the character function fputc

The fputc function writes a character to a specified file. The function is called in the form of fputc (character quantity, file pointer, the number of characters to be written can be a character constant or variable, for example, fputc ('A', FP). It means to write character a to the file pointed to by FP.

The usage of fputc functions should also be described as follows:

1. the written file can be opened by using, writing, reading, and writing. When an existing file is opened by writing or reading/writing, the original file content will be cleared, the write character starts from the beginning of the file. To retain the content of the original file and store the characters to be written at the end of the file, the file must be opened in append mode. If the file to be written does not exist, the file is created.

2. Each time a character is written, the internal position pointer of the file moves one byte backward.

3. The fputc function has a return value. If the write is successful, the written character is returned. Otherwise, an EOF is returned. This can be used to determine whether the write is successful.

[Example 10.2] enter a line of characters from the keyboard, write a file, and read the file content and display it on the screen.

# Include <stdio. h>
Main ()
{
File * FP;
Char ch;
If (FP = fopen ("string", "WT +") = NULL)
{
Printf ("cannot open file strike any key exit! ");
Getch ();
Exit (1 );
}
Printf ("input a string:/N ");
Ch = getchar ();
While (Ch! = '/N ')
{
Fputc (CH, FP );
Ch = getchar ();
}
Rewind (FP );
Ch = fgetc (FP );
While (Ch! = EOF)
{
Putchar (CH );
Ch = fgetc (FP );
}
Printf ("/N ");
Fclose (FP );
}

The second line in the program opens the string file in the form of reading and writing text files. The program reads a character from the keyboard in line 3 and then enters the loop. When the character is not a carriage return, the program writes the character into the file and continues to read the next character from the keyboard. Each time one character is entered, the internal position pointer of the file moves one byte backward. After writing, the pointer is directed to the end of the file. To read the file from the beginning, you must move the pointer to the file header. The program's 19th-line rewind function is used to move the internal position pointer of the file referred to by FP to the file header. Lines 20th to 25 are used to read a row of content from the file.

[Example 10.3] copy the file marked by the previous file name in the command line parameter to the file marked by the last file name, if there is only one file name in the command line, the file will be written to the standard output file (Display.

# Include <stdio. h>
Main (INT argc, char * argv [])
{
File * FP1, * fp2;
Char ch;
If (argc = 1)
{
Printf ("have not enter file name strike any key exit ");
Getch ();
Exit (0 );
}
If (FP1 = fopen (argv [1], "RT") = NULL)
{
Printf ("cannot open % s/n", argv [1]);
Getch ();
Exit (1 );
}
If (argc = 2) fp2 = stdout;
Else if (fp2 = fopen (argv [2], "WT +") = NULL)
{
Printf ("cannot open % s/n", argv [1]);
Getch ();
Exit (1 );
}
While (CH = fgetc (FP1 ))! = EOF)
Fputc (CH, fp2 );
Fclose (FP1 );
Fclose (fp2 );
}

This program is the main function with parameters. The program defines two file pointers: FP1 and fp2, respectively pointing to the file given in the command line parameters. If the command line parameter does not provide a file name, a prompt is displayed. Line 2 of the program indicates that if only one file name is given, fp2 is directed to the standard output file (Display ). The program reads the characters in file 1 one by one with loop statements from lines 2 to 28 and then sends them to file 2. A file name (a file set up in example 10.2) is provided during the re-running, so stdout is output to the standard output file, that is, the file content is displayed on the display. In the third run, two file names are provided, so the content in the string is read and written to OK. You can use the doscommand type to display the OK content: