14.4. Processing Files

To process [verb 1, 2.b] something means "to subject [it] to or handle [it] through an established usually routine set of procedures." "Processing files" implies processing the data in them, subjecting it to a set of procedures - algorithmically manipulating it. Programmers must consider two aspects of file processing when writing programs: the order in which the program reads or writes the file and the units or "chunks" the program reads or writes.

I/O Units and Access Order

Data consists of one or more bytes that programs group into logical "chunks," which the text calls "I/O units" to distinguish them from the physical "chunks" or blocks transferred between the program and the computer's hardware. Programs can process files in two orders: sequentially or randomly. Sequential processing accesses a file from beginning to end, with each read or write operation advancing the position pointer by the I/O unit size. The term "random" in "random access" doesn't mean that programs access data by chance but can access the data in any order, often responding to an outside request. The synonym "direct" suggests that a program can go directly to any data element using an index and one of the "seek" functions. Programmers synthesize a third order, keyed or indexed access, by extending random access. The underlying problem determines the I/O unit's size and the file's access order. The access order determines which stream classes programs use, while the I/O unit determines the I/O functions.

File Processing Control

Programs reading files sequentially often use loops to iterate through their contents, interleaving reading and data processing operations. The operating system manages the computer hardware, including access to secondary memory, making it further responsible for detecting and signaling when a program reaches the end of a file. The stream classes present a consistent interface, independent of the hardware and the operating system, providing programs with many ways to detect the signal.

The eof Function

Each stream object has a set of four one-bit flags maintaining the associated file's current state or condition. One of those flags, eofbit, saves the stream's "end of file" status. The last read operation sets the bit to "1" if it advances the stream's position pointer to the end of the file; otherwise, it leaves the bit set to "0." The eof or end of file function returns the current value of the eofbit, providing loop control for processing a file's contents.

ifstream file(file_name);

while (! file.eof())
{
	// read file
	// process data
}
 

ifstream file(file_name);

// initial file read
while (! file.eof())
{
	// process the data
	// subsequent file reads
}

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream in("data.txt");
    char c;

    while (!in.eof())
    {
        in >> c;
        // in.get(c);	// alternate
        cout << '|' << c << '|' << endl;
    }

    return 0;
}

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream in("data.txt");

    while (!in.eof())
    {
        int c = in.get();
        cout << '|' << (char)c
            << '|' << endl;
    }

    return 0;
}
 

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream in("data2.txt");
    char line[100];

    while (!in.eof())
    {
        in.getline(line, 100);
        cout << '|' << line
            << '|' << endl;
    }

    return 0;
}

|a|
|b|
|c|
|d|
|d|

|a|
|b|
|c|
|d|
| |

|See the quick|
|red fox jump|
|over the lazy|
|brown dog.|

The EOF Constant

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream in("data.txt");
    int c;
    
    while ((c = in.get()) != EOF) 
        cout << '|' << (char)c << '|' << endl;

    return 0;
}

operator( )

The C++ operator summary lists three distinct operators implemented with parentheses in the second group of operators. The input stream classes overload the third, type-casting operator, to form a conversion operator: bool operator() function. The following figure presents a function prototype and code fragments demonstrating how programs use the conversion operator to read a file.

ifstream& get(char& c);

ifstream input(file_name);

do {
	...
} while (input);

char c;
while (input.get(c))
	. . .