More Examples of Disk File I/O
The following sections show several more examples of disk file I/O, such as reading and writing binary data and redirecting the standard streams. Three more I/O functions, fscanf(), fprintf(), and freopen(), are introduced, too.
Reading and Writing Binary Data
As you learned in Hour 21, "Disk File Input and Output: Part I," you can indicate to the compiler that you're going to open a binary file by setting a proper mode when calling the fopen() function. For instance, the following statement tries to open an existing binary file for reading:
fptr = fopen("test.bin", "rb");
Note that the "rb" mode is used to indicate that the file we're going to open for reading is a binary file.
Listing 22.2 contains an example of reading and writing binary data.
TYPE
Listing 22.2. Reading and writing binary data.
1: /* 22L02.c: Reading and writing binary data */
2: #include <stdio.h>
3:
4: enum {SUCCESS, FAIL, MAX_NUM = 3};
5:
6: void DataWrite(FILE *fout);
7: void DataRead(FILE *fin);
8: int ErrorMsg(char *str);
9:
10: main(void)
11: {
12: FILE *fptr;
13: char filename[]= "double.bin";
14: int reval = SUCCESS;
15:
16: if ((fptr = fopen(filename, "wb+")) == NULL){
17: reval = ErrorMsg(filename);
18: } else {
19: DataWrite(fptr);
20: rewind(fptr); /* reset fptr */
21: DataRead(fptr);
22: fclose(fptr);
23: }
24:
25: return reval;
26: }
27: /* function definition */
28: void DataWrite(FILE *fout)
29: {
30: int i;
31: double buff[MAX_NUM] = {
32: 123.45,
33: 567.89,
34: 100.11};
35:
36: printf("The size of buff: %d-byte\n", sizeof(buff));
37: for (i=0; i<MAX_NUM; i++){
38: printf("%5.2f\n", buff[i]);
39: fwrite(&buff[i], sizeof(double), 1, fout);
40: }
41: }
42: /* function definition */
43: void DataRead(FILE *fin)
44: {
45: int i;
46: double x;
47:
48: printf("\nRead back from the binary file:\n");
49: for (i=0; i<MAX_NUM; i++){
50: fread(&x, sizeof(double), (size_t)1, fin);
51: printf("%5.2f\n", x);
52: }
53: }
54: /* function definition */
55: int ErrorMsg(char *str)
56: {
57: printf("Cannot open %s.\n", str);
58: return FAIL;
59: }
OUTPUT
After running the executable 22L02.exe, I have the following output on the screen:
C:\app>22L02
The size of buff: 24-byte
123.45
567.89
100.11
Read back from the binary file:
123.45
567.89
100.11
C:\app>
ANALYSIS
The purpose of the program in Listing 22.2 is to write three values of the double data type into a binary file and then rewind the file position indicator and read back the three double values from the binary file. The two functions, DataWrite() and DataRead(), that perform the writing and reading, are declared in lines 6 and 7.
The enum names, SUCCESS, FAIL, and MAX_NUM, are defined in line 4 with values of 0, 1, and 3, respectively.
Inside the main() function, the statement in line 16 tries to create and open a binary file called double.bin for both reading and writing. Note that the "wb+" mode is used in the fopen() function in line 16.
If the fopen() function is successful, the DataWrite() function is called in line 19 to write three double data items, 123.45, 567.89, and 100.11, into the opened binary file, according to the definition of the DataWrite() function in lines 28_41. The fwrite() function in line 39 does the writing. Because the three double data items are saved in an array named buff, we also measure and print out the size of the buff array in line 36. On my machine, the size of the buff array is 24 bytes because each double data item is 8 bytes.
Right after the execution of the DataWrite() function, the file position indicator is reset to the beginning of the binary file by calling the rewind() function in line 20 because we want to read back all three double data items written to the file.
Then in line 21, the DataRead() function reads the three double data items from the opened binary file double.bin. From the definition of the DataRead() function in lines 43_53, you can see that the fread() function is used to perform the reading operation (see line 50).
The output from running the program in Listing 22.2 shows the three double data items before the writing and after the reading as well.
The fscanf() and fprintf() Functions
As you learned, the two C library functions scanf() and printf() can be used to read or write formatted data through the standard I/O (that is, stdin and stdout). Among the C disk file I/O functions, there are two equivalent functions, fscanf() and fprintf(), that can do the same jobs as the scanf() and printf() functions. In addition, the fscanf() and fprintf() functions allow the programmer to specify I/O streams.
The syntax for the fscanf() function is
#include <stdio.h>
int fscanf(FILE *stream, const char *format, …);
Here stream is the file pointer associated with an opened file. format, whose usage is the same as in the scanf() function, is a char pointer pointing to a string that contains the format specifiers. If successful, the fscanf() function returns the number of data items read. Otherwise, the function returns EOF.
The syntax for the fprintf() function is
#include <stdio.h>
int fprintf(FILE *stream, const char *format, …);
Here stream is the file pointer associated with an opened file. format, whose usage is the same as in the printf() function, is a char pointer pointing to a string that contains the format specifiers. If successful, the fprintf() function returns the number of formatted expressions. Otherwise, the function returns a negative value.
To know more about the fprintf() and fscanf() functions, you can review the explanations on the printf() and scanf() functions in Hour 5, "Reading from and Writing to Standard I/O," and Hour 13, "Manipulating Strings."
The program in Listing 22.3 demonstrates how to use the fscanf() and fprintf() functions to read and write differently typed data items.
TYPE
Listing 22.3. Using the fscanf() and fprintf() functions.
1: /* 22L03.c: Using the fscanf() and fprintf() functions */
2: #include <stdio.h>
3:
4: enum {SUCCESS, FAIL,
5: MAX_NUM = 3,
6: STR_LEN = 23};
7:
8: void DataWrite(FILE *fout);
9: void DataRead(FILE *fin);
10: int ErrorMsg(char *str);
11:
12: main(void)
13: {
14: FILE *fptr;
15: char filename[]= "strnum.mix";
16: int reval = SUCCESS;
17:
18: if ((fptr = fopen(filename, "w+")) == NULL){
19: reval = ErrorMsg(filename);
20: } else {
21: DataWrite(fptr);
22: rewind(fptr);
23: DataRead(fptr);
24: fclose(fptr);
25: }
26:
27: return reval;
28: }
29: /* function definition */
30: void DataWrite(FILE *fout)
31: {
32: int i;
33: char cities[MAX_NUM][STR_LEN] = {
34: "St.Louis->Houston:",
35: "Houston->Dallas:",
36: "Dallas->Philadelphia:"};
37: int miles[MAX_NUM] = {
38: 845,
39: 243,
40: 1459};
41:
42: printf("The data written:\n");
43: for (i=0; i<MAX_NUM; i++){
44: printf("%-23s %d miles\n", cities[i], miles[i]);
45: fprintf(fout, "%s %d", cities[i], miles[i]);
46: }
47: }
48: /* function definition */
49: void DataRead(FILE *fin)
50: {
51: int i;
52: int miles;
53: char cities[STR_LEN];
54:
55: printf("\nThe data read:\n");
56: for (i=0; i<MAX_NUM; i++){
57: fscanf(fin, "%s%d", cities, &miles);
58: printf("%-23s %d miles\n", cities, miles);
59: }
60: }
61: /* function definition */
62: int ErrorMsg(char *str)
63: {
64: printf("Cannot open %s.\n", str);
65: return FAIL;
66: }
OUTPUT
The following output is shown on the screen after the executable 22L03.exe is created and run:
C:\app>22L03
The data written:
St.Louis->Houston: 845 miles
Houston->Dallas: 243 miles
Dallas->Philadelphia: 1459 miles
The data read:
St.Louis->Houston: 845 miles
Houston->Dallas: 243 miles
Dallas->Philadelphia: 1459 miles
C:\app>
ANALYSIS
The purpose of the program in Listing 22.3 is to write data items of different types into a file with the help of the fprintf() function and read back the data items in the same format by calling the fscanf() functions. The two functions declared in lines 8 and 9, DataWrite() and DataRead(), actually perform the writing and reading.
The statement of the main() function in line 18 tries to create and open a text file called strnum.mix for both reading and writing by specifying the second argument to the fopen() function as "w+". If fopen() does not return a null pointer, the DataWrite() function is called in line 21 to write strings and int data items into the strnum.mix file. Note that the fprintf() function is invoked inside the DataWrite() function in line 45 to write the formatted data into the text file.
From the definition of the DataWrite() function in lines 30_47, you can see that there are two arrays, cities and miles. The cities array contains three strings that indicate three pairs of cities, and the miles array has three int values representing the corresponding distances between the cities shown in the cities array. For instance, 845 in the miles array is the distance (in miles) between the two cities expressed by the string St.Louis->Houston: in the cities array.
In line 22, the rewind() function is called to rewind the file position indicator and reset it to the beginning of the strnum.mix file. Then the DataRead() function in line 23 reads back what has been saved in strnum.mix with the help of the fscanf() function. The definition of the DataRead() function is shown in lines 49_60.
From this example, you see that it is convenient to use the fprintf() and fscanf() functions together to perform formatted disk file I/O operations.
Redirecting the Standard Streams with freopen()
In Hour 5 you learned how to read from or write to standard I/O. Also, you were told that the C functions, such as getc(), gets(), putc, and printf(), direct their I/O operations automatically to either stdin or stdout.
In this section you're going to learn how to redirect the standard streams, such as stdin and stdout, to disk files. A new C function you're going to use is called freopen(), which can associate a standard stream with a disk file.
The syntax for the freopen() function is
#include <stdio.h>
FILE *freopen(const char *filename, const char *mode, FILE *stream);
Here filename is a char pointer referencing the name of a file that you want to associate with the standard stream represented by stream. mode is another char pointer pointing to a string that defines the way to open a file. The values that mode can have in freopen() are the same as the mode values in the fopen() function. (The definition of all mode values is given in Hour 21.)
The freopen() function returns a null pointer if an error occurs. Otherwise, the function returns the standard stream that has been associated with a disk file identified by filename.
Listing 22.4 demonstrates an example of redirecting the standard output, stdout, with the help of the freopen() function.
TYPE
Listing 22.4. Redirecting the standard stream stdout.
1: /* 22L04.c: Redirecting a standard stream */
2: #include <stdio.h>
3:
4: enum {SUCCESS, FAIL,
5: STR_NUM = 4};
6:
7: void StrPrint(char **str);
8: int ErrorMsg(char *str);
9:
10: main(void)
11: {
12: char *str[STR_NUM] = {
13: "Be bent, and you will remain straight.",
14: "Be vacant, and you will remain full.",
15: "Be worn, and you will remain new.",
16: "---- by Lao Tzu"};
17: char filename[]= "LaoTzu.txt";
18: int reval = SUCCESS;
19:
20: StrPrint(str);
21: if (freopen(filename, "w", stdout) == NULL){
22: reval = ErrorMsg(filename);
23: } else {
24: StrPrint(str);
25: fclose(stdout);
26: }
27: return reval;
28: }
29: /* function definition */
30: void StrPrint(char **str)
31: {
32: int i;
33:
34: for (i=0; i<STR_NUM; i++)
35: printf("%s\n", str[i]);
36: }
37: /* function definition */
38: int ErrorMsg(char *str)
39: {
40: printf("Cannot open %s.\n", str);
41: return FAIL;
42: }
OUTPUT
Note that if you're using Microsoft Visual C++ on your machine, you need to make sure the project type is set to MS-DOS application (.EXE). Don't set the project type to QickWin application (.EXE) or other Windows application types, because there might be some conflicts between a Windows environment and the freopen() function. After the executable 22L04.exe is created and run, the following output is printed on the screen:
C:\app>22L04
Be bent, and you will remain straight.
Be vacant, and you will remain full.
Be worn, and you will remain new.
---- by Lao Tzu
C:\app>
ANALYSIS
The purpose of the program in Listing 22.4 is to save a paragraph of Tao Te Ching written by a Chinese philosopher, Lao Tzu, into a text file, LaoTzu.txt. To do so, we call the printf() function instead of the fprintf() function or other disk I/O functions after we redirect the default stream, stdout, of the printf() function to point to the text file.
The function that actually does the writing is called StrPrint(), which invokes the C function printf() to send out formatted character strings to the output stream. (See the definition of the StrPrint() function in lines 30_36.)
Inside the main() function, we call the StrPrint() function in line 20 before we redirect stdout to the LaoTzu.txt file. It's not surprising to see that the paragraph adopted from Tao Te Ching is printed on the screen because the printf() function automatically sends out the paragraph to stdout that directs to the screen by default.
Then, in line 21, we redirect stdout to the LaoTzu.txt text file by calling the freopen() function. There the "w" is used as the mode that indicates to open the text file for writing. If freopen() is successful, we then call the StrPrint() function in line 24. However, this time, the StrPrint() function writes the paragraph into the opened text file, LaoTzu.txt. The reason is that stdout is now associated with the text file, not the screen, so that strings sent out by the printf() function inside StrPrint() are directed to the text file.
After the execution of the program in Listing 22.4, you can open the LaoTzu.txt file in a text editor and see that the paragraph of Tao Te Ching has been saved in the file.
NOTE
As mentioned previously, the I/O streams are buffered by default. Occasionally, you may want to turn off the buffering so that you can process the input immediately. In C there are two functions, setbuf() and setvbuf(), that can be used to turn off the buffering. Appendix B contains the syntax of the two functions, although unbuffering I/O is beyond the scope of this book.
Also, there is a set of low-level I/O functions, such as open(), create(), close(), read(), write(), lseek(), and tell(), which are not sup-ported by the ANSI C standard. You may still see them in some platform-dependent C programs. To use them, you need to read your C compiler's reference manual to make sure they're available.
