Random Access to Disk Files
So far you've learned how to read or write data sequentially to an opened disk file, known as sequential access. In other words, you start with the first byte and keep reading or writing each successive byte in order. In many cases, however, you need to access particular data somewhere in the middle of a disk file. One way to do this is to keep reading data from the file until the particular data is fetched. Obviously, this is not an efficient way, especially when the file contains many data items.
Random access is another way to read or write data to disk files. In random access, specific file elements can be accessed in random order (that is, without reading through all the preceding data).
In C there are two I/O functions, fseek() and ftell(), that are designed to deal with random access.
The fseek() and ftell() Functions
As just mentioned, we need functions that enable us to access files randomly. The fseek() and ftell() functions provide us with such a capability.
In the previous lesson you learned that one of the members in the FILE structure is called the file position indicator. The file position indicator has to point to the desired position in a file before data can be read from or written to there. You can use the fseek() function to move the file position indicator to the spot you want to access in a file.
The syntax for the fseek() function is
#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
Here stream is the file pointer associated with an opened file. offset indicates the number of bytes from a fixed position, specified by whence, that can have one of the following integral values represented by SEEK_SET, SEEK_CUR, and SEEK_END. If it is successful, the fseek() function returns 0; otherwise, the function returns a nonzero value.
You can find the values represented by SEEK_SET, SEEK_CUR, and SEEK_END in the header file stdio.h.
If SEEK_SET is chosen as the third argument to the fseek() function, the offset is counted from the beginning of the file and the value of the offset is greater than or equal to zero. If, however, SEEK_END is picked up, then the offset starts from the end of the file; the value of the offset should be negative. When SEEK_CUR is passed to the fseek() function, the offset is calculated from the current value of the file position indicator.
You can obtain the value of the current file position indicator by calling the ftell() function.
The syntax for the ftell() function is
#include <stdio.h>
long ftell(FILE *stream);
Here stream is the file pointer associated with an opened file. The ftell() function returns the current value of the file position indicator.
The value returned by the ftell() function represents the number of bytes from the beginning of the file to the current position pointed to by the file position indicator.
If the ftell() function fails, it returns -1L (that is, a long value of minus 1). One thing that can cause the failure of the ftell() function is the file being a terminal or some other type for which the file position indicator becomes meaningless.
The program in Listing 22.1 shows how to randomly access a disk file by using the fseek() and ftell() functions.
TYPE
Listing 22.1. Random access to a file.
1: /* 22L01.c: Random access to a file */
2: #include <stdio.h>
3:
4: enum {SUCCESS, FAIL, MAX_LEN = 80};
5:
6: void PtrSeek(FILE *fptr);
7: long PtrTell(FILE *fptr);
8: void DataRead(FILE *fptr);
9: int ErrorMsg(char *str);
10:
11: main(void)
12: {
13: FILE *fptr;
14: char filename[]= "haiku.txt";
15: int reval = SUCCESS;
16:
17: if ((fptr = fopen(filename, "r")) == NULL){
18: reval = ErrorMsg(filename);
19: } else {
20: PtrSeek(fptr);
21: fclose(fptr);
22: }
23:
24: return reval;
25: }
26: /* function definition */
27: void PtrSeek(FILE *fptr)
28: {
29: long offset1, offset2, offset3;
30:
31: offset1 = PtrTell(fptr);
32: DataRead(fptr);
33: offset2 = PtrTell(fptr);
34: DataRead(fptr);
35: offset3 = PtrTell(fptr);
36: DataRead(fptr);
37:
38: printf("\nRe-read the haiku:\n");
39: /* re-read the third verse of the haiku */
40: fseek(fptr, offset3, SEEK_SET);
41: DataRead(fptr);
42: /* re-read the second verse of the haiku */
43: fseek(fptr, offset2, SEEK_SET);
44: DataRead(fptr);
45: /* re-read the first verse of the haiku */
46: fseek(fptr, offset1, SEEK_SET);
47: DataRead(fptr);
48: }
49: /* function definition */
50: long PtrTell(FILE *fptr)
51: {
52: long reval;
53:
54: reval = ftell(fptr);
55: printf("The fptr is at %ld\n", reval);
56:
57: return reval;
58: }
59: /* function definition */
60: void DataRead(FILE *fptr)
61: {
62: char buff[MAX_LEN];
63:
64: fgets(buff, MAX_LEN, fptr);
65: printf("---%s", buff);
66: }
67: /* function definition */
68: int ErrorMsg(char *str)
69: {
70: printf("Cannot open %s.\n", str);
71: return FAIL;
72: }
OUTPUT
I have the following output shown on my screen after running the executable 22L01.exe of the program in Listing 22.1:
C:\app>22L01
The fptr is at 0
---Leading me along
The fptr is at 18
---my shadow goes back home
The fptr is at 44
---from looking at the moon.
Re-read the haiku:
---from looking at the moon.
---my shadow goes back home
---Leading me along
C:\app>
ANALYSIS
The purpose of the program in Listing 22.1 is to move the file position indicator around in order to read different verses from the haiku.txt file.
Inside the main() function, a file pointer fptr is defined in line 13, and the name of the haiku.txt file is assigned to the array called filename in line 14. Then, in line 17, we try to open the haiku.txt file for reading by calling the fopen() function. If successful, we invoke the PtrSeek() function with the fptr file pointer as the argument in line 20.
The definition of our first function PtrSeek() is shown in lines 27_48. The statement in line 31 obtains the original value of the fptr file pointer by calling another function, PtrTell(), which is defined in lines 50_58. The PtrTell() function can find and print out the value of the file position indicator with the help of the C ftell() function. The original value of the file position indicator contained by fptr is assigned to the long variable offset1 in line 31.
In line 32, the third function, DataRead(), is called to read one line of characters from the opened file and print out the line of characters on the screen. Line 33 gets the value of the fptr file position indicator right after the reading and assigns the value to another long variable, offset2.
Then the DataRead() function in line 34 reads the second line of characters from the opened file. Line 35 obtains the value of the file position indicator that points to the first byte of the third verse and assigns the value to the third long variable offset3. Line 36 calls the DataRead() function to read the third verse and print it out on the screen.
Therefore, from the first portion of the output, you can see the three different values of the file position indicator at three different positions, and the three verses of the haiku written by Sodo. The three values of the file position indicator are saved respectively by offset1, offset2, and offset3.
Now, starting from line 40 to line 47, we read Sodo's haiku backward, one verse at a time. That is, we read the third verse first, then the second verse, and finally the first verse. To do so, we first call the fseek() function to move the file position indicator to the beginning of the third verse by passing the value contained by offset3 to the function. Then we call fseek() again and pass the value of offset2 to the function so that the file position indicator is set to point to the first byte of the second verse. Finally, we move the file position indicator to the beginning of the first verse by passing the value of offset1 to the fseek() function. Therefore, in the second portion of the output, you see the three verses of the haiku in reverse order.
The rewind() Function
Sometimes you might want to reset the file position indicator and put it at the beginning of a file. There is a handy C function, called rewind(), that can be used to rewind the file position indicator.
The syntax for the rewind() function is
#include <stdio.h>
void rewind(FILE *stream);
Here stream is the file pointer associated with an opened file. No value is returned by the rewind() function.
In fact, the following statement of the rewind() function
rewind(fptr);
is equivalent to this:
(void)fseek(fptr, 0L, SEEK_SET);
Here the void data type is cast to the fseek() function because the rewind() function does not return a value. Listing 22.2 contains an example that calls the rewind() function to move the file position indicator to the beginning of an opened file.
