14.10. Random and Direct Access

The current chapter began with two figures. The first suggests that a file looks like an array of bytes with a position pointer indicating where the program is currently reading or writing data. The second illustrates the primary C++ input/output system classes. Significantly, the iostream class has two superclasses, istream and ostream, and inherits a position pointer from each. So, fstream, a subclass of iostream, has two position pointers, one for input and one for output.

When it is important to do so, we distinguish the two pointers as "get" (read or input) and "put" (write or output). In preparation for accessing a specific data item, the program moves the pointers within a file with one of four overloaded "seek" functions. The next I/O operation occurs at the new position in the file. Additionally, two "tell" functions report a stream's current position within a file. The name of each function ends with either a "p" or a "g" to denote a specific pointer.

istream& seekg(streampos pos);

ostream& seekp(streampos pos);

istream& seekg(streampos off, ios::seekdir loc);

ostream& seekp(streampos off, ios::seekdir loc);

streampos tellg();

streampos tellp();

Direct Access

In the Block I/O section, we learned that we can group the bytes together to form blocks or records, and that we can read and write block-oriented files sequentially. We can implement direct access by combining block I/O, the file positioning functions, and records. The previous discussion specified the seek positions in bytes. But a file of records looks and behaves very much like an array of objects. If we index into an array of objects, the compiler automatically converts the array index into a byte address in memory. To implement direct access, we need a way to map a record number (aka block number), the analog of an array index, to a byte address within the file. Unfortunately, C++ doesn't have a way to complete the mapping automatically, so we must do it manually.

byte address = record number × size of a record
record number = byte address / size of a record
(a)

struct chunk { . . . };

byte = record * sizeof(chunk);
record = byte / sizeof(chunk);

(b)

byte = 7 * 10 = 70
record = 70 / 10 = 7

(c)

(d)

Common Programming Patterns

struct chunk { . . . };
chunk c;
fstream data;

data.seekp(0, ios::end);
data.write((char *) &c, sizeof(chunk));

data.seekg(0);
data.read((char *) &c, sizeof(chunk));

data.seekg(0);
while (data.read((char *) &c, sizeof(chunk)))
	....

data.seekp(data.tellg() - (streampos)sizeof(chunk));
data.write((char *) &c, sizeof(chunk));

data.seekp(ios::cur, -(streampos)sizeof(chunk));
data.write((char *) &c, sizeof(chunk));

data.seekp(0, ios::end);		  // (a)
streampos pos = data.getp();
data.write((char *) &c, sizeof(chunk));
		. . .
data.seekg(pos);			  // (b)
data.read((char *) &c, sizeof(chunk));
		. . .
data.seekp(pos);			  // (c)
data.write((char *) &c, sizeof(chunk));