lafore_robert_objectoriented_programming_in_c

You’ve seen some of these functions, such as get(), before. Most of them operate on the cin object, which usually represents the data flow from the keyboard. However, the last four deal specifically with disk files.

The ostream Class

The ostream class handles output or insertion activities. Table 12.7 shows the most commonly used member functions of this class. The last four functions in this table deal specifically with disk files.

TABLE 12.7 ostream Functions

575

12

AND S

F TREAMS

ILES

Stream Errors

So far in this book we’ve mostly used a rather straightforward approach to input and output, using statements of the form

cout << “Good morning”;

and

cin >> var;

However, as you may have discovered, this approach assumes that nothing will go wrong during the I/O process. This isn’t always the case, especially with input. What happens if a user enters the string “nine” instead of the integer 9, or pushes the Enter key without entering anything? Or what happens if there’s a hardware failure? In this section we’ll explore such problems. Many of the techniques we’ll see here are applicable to file I/O as well.

Error-Status Bits

The stream error-status flags constitute an ios enum member that reports errors that occurred in an input or output operation. They’re summarized in Table 12.8. Figure 12.3 shows how these flags look. Various ios functions can be used to read (and even set) these error flags, as shown in Table 12.9.

TABLE 12.8 Error-Status Flags

12

AND S

F TREAMS

ILES

The most common error this scheme detects when reading keyboard input is the user typing nondigits (for instance, “nine” instead of “9”). This causes the failbit to be set. However, it also detects system-related failures that are more common with disk files.

Floating-point numbers (float, double, and long double) can be analyzed for errors in the same way as integers.

Too Many Characters

Too many characters sounds like a difficulty experienced by movie directors, but extra characters can also present a problem when reading from input streams. This is especially true when there are errors. Typically, extra characters are left in the input stream after the input is supposedly completed. They are then passed along to the next input operation, even though they are not intended for it. Often it’s a newline character that remains behind, but sometimes other characters are left over as well. To get rid of these extraneous characters the ignore(MAX, DELIM) member function of istream is used. It reads and throws away up to MAX characters, including the specified delimiter character. In our example, the line

cin.ignore(10, ‘\n’);

causes cin to read up to 10 characters, including the ‘\n’, and remove them from the input.

No-Input Input

Whitespace characters, such as tab space and ‘\n’, are normally ignored (skipped) when inputting numbers. This can have some undesirable side effects. For example, users, prompted to enter a number, may simply press the Enter key without typing any digits. (Perhaps they think that this will enter 0, or perhaps they are simply confused.) In the code shown above, as well as the simple statement

cin >> i;

pressing Enter causes the cursor to drop down to the next line, while the stream continues to wait for the number. What’s wrong with the cursor dropping to the next line? First, inexperienced users, seeing no acknowledgment when they press Enter, may assume the computer is broken. Second, pressing Enter repeatedly normally causes the cursor to drop lower and lower until the entire screen begins to scroll upward. This is all right in teletype-style interaction, where the program and the user simply type at each other. However, in text-based graphics programs (such as the ELEV program in Chapter 13, “Multifile Programs”), scrolling the screen disarranges and eventually obliterates the display.

12

AND S

F TREAMS

ILES

Streams and Files

The inches value is a floating-point number. We want to check its range, which should be 0 or greater but less than 12.0. We also check it for ios error flags. Most commonly, the failbit will be set because the user typed nondigits instead of a number. Here’s the listing for

ENGLERR:

//englerr.cpp

//input checking with English Distance class #include <iostream>

#include <string>

////////////////////////////////////////////////////////////////

cout << “Feet must be an integer less than 1000\n”;

}//end while feet

581

12

AND S

F TREAMS

ILES

We’ve used another dodge here: setting an error-state flag manually. We do this because we want to ensure that the inches value is greater than 0 but less than 12.0. If it isn’t, we turn on the failbit with the statement

cin.clear(ios::failbit); // set failbit

When the program checks for errors with cin.good(), it will find the failbit set and signal that the input is incorrect.

Disk File I/O with Streams

Most programs need to save data to disk files and read it back in. Working with disk files requires another set of classes: ifstream for input, fstream for both input and output, and ofstream for output. Objects of these classes can be associated with disk files, and we can use their member functions to read and write to the files.

Referring back to Figure 12.1, you can see that ifstream is derived from istream, fstream is derived from iostream, and ofstream is derived from ostream. These ancestor classes are in turn derived from ios. Thus the file-oriented classes derive many of their member functions from more general classes. The file-oriented classes are also derived, by multiple inheritance, from the fstreambase class. This class contains an object of class filebuf, which is a fileoriented buffer, and its associated member functions, derived from the more general streambuf class. You don’t usually need to worry about these buffer classes.

The ifstream, ofstream, and fstream classes are declared in the FSTREAM file.

C programmers will note that the approach to disk I/O used in C++ is quite different from that in C. The old C functions, such as fread() and fwrite(), will still work in C++, but they are not so well suited to the object-oriented environment. The new C++ approach is considerably cleaner and easier to implement. (Incidentally, be careful about mixing the old C functions with C++ streams. They don’t always work together gracefully, although there are ways to make them cooperate.)

Formatted File I/O

In formatted I/O, numbers are stored on disk as a series of characters. Thus 6.02, rather than being stored as a 4-byte type float or an 8-byte type double, is stored as the characters ‘6’, ‘.’, ‘0’, and ‘2’. This can be inefficient for numbers with many digits, but it’s appropriate in many situations and easy to implement. Characters and strings are stored more or less normally.

12

AND S

F TREAMS

ILES