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

Imagine using a word processor: it can edit short or long files. It can remove or add text to the file, changing its size. Generalizing this observation suggests that programs reading files should operate independently of the file's size. 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, (mostly) 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, the end-of-file or eofbit, saves the stream's reading status. The end-of-file function, eof, returns this saved value. However, it's the read operations, not the eof function, that sets the eofbit flag, and they only set it when they attempt and fail to read data. This sequence explains why there is a lag between setting the eofbit and the eof function detecting the stream's end.

ifstream file(file_name);

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

ifstream file(file_name);

// initial file read		// 1
while (! file.eof())		// 2
{
	// process data		// 3
	// read file		// 4
}

#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("data.txt");
    char c;

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

    return 0;
}

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

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

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

#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;
}
 

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

int main()
{
    ifstream in("data2.txt");
    string line;

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

    return 0;
}

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

|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 bool

Programs often need to convert one data type to another, and C++ gives programmers two methods for implementing the automatic conversion. They use conversion constructors to convert a type to an instance of a class they "own." Ownership implies that a programmer can edit and incorporate a class into programs. However, the C++ compiler defines the fundamental types, and programmers cannot modify them. So, to convert an instance of their class to a fundamental type, they use a conversion operator. From the perspective of a programmer-owned class, "think of constructors pulling data into an object and operators pushing it out" (Constructor vs. Operator). This example demonstrates a stream-class-define a conversion operator that converts a stream object into a Boolean value.

explicit operator bool() const;

ifstream& get(char& c);

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

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

    while (in.get(c))
        cout << '|' << c << '|' << endl;

    return 0;
}
 
 

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

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

    do {
        in.get(c);
        cout << '|' << c << '|' << endl;
    } while (in);

    return 0;
}