lafore_robert_objectoriented_programming_in_c

Chapter 12

586

Here the ifstream object, which we name infile, acts much the way cin did in previous programs. Provided that we have formatted the data correctly when inserting it into the file, there’s no trouble extracting it, storing it in the appropriate variables, and displaying its contents. The program’s output looks like this:

x 77

6.02 Kafka Proust

Of course the numbers are converted back to their binary representations for storage in the program. That is, the 77 is stored in the variable j as a type int, not as two characters, and the 6.02 is stored as a double.

Strings with Embedded Blanks

The technique of our last examples won’t work with char* strings containing embedded blanks. To handle such strings, you need to write a specific delimiter character after each string, and use the getline()function, rather than the extraction operator, to read them in. Our next program, OLINE, outputs some strings with blanks embedded in them.

//create file for output //send text to file

outfile << “I fear thee, ancient Mariner!\n”; outfile << “I fear thy skinny hand\n”;

outfile << “And thou art long, and lank, and brown,\n”; outfile << “As is the ribbed sea sand.\n”;

return 0;

}

When you run the program, the lines of text (from Samuel Taylor Coleridge’s The Rime of the Ancient Mariner) are written to a file. Each one is specifically terminated with a newline (‘\n’) character. Note that these are char* strings, not objects of the string class. Many stream operations work more easily with char* strings.

To extract the strings from the file, we create an ifstream and read from it one line at a time using the getline() function, which is a member of istream. This function reads characters,

Chapter 12

588

You can also test the stream directly. Any stream object, such as infile, has a value that can be tested for the usual error conditions, including EOF. If any such condition is true, the object returns a zero value. If everything is going well, the object returns a nonzero value. This value is actually a pointer, but the “address” returned has no significance except to be tested for a zero or nonzero value. Thus we can rewrite our while loop again:

while( infile ) // until any error encountered

This is certainly simple, but it may not be quite so clear to the uninitiated what it does.

Character I/O

The put() and get() functions, which are members of ostream and istream, respectively, can be used to output and input single characters. Here’s a program, OCHAR, that outputs a string, one character at a time:

//ochar.cpp

//file output with characters

using namespace std;

int main()

{

string str = “Time is a great teacher, but unfortunately “ “it kills all its pupils. Berlioz”;

In this program an ofstream object is created as it was in OLINE. The length of the string object str is found using the size() member function, and the characters are output using put() in a for loop. The aphorism by Hector Berlioz (a 19th-century composer of operas and program music) is written to the file TEST.TXT. We can read this file back in and display it using the ICHAR program.

//ichar.cpp

//file input with characters

using namespace std;

Chapter 12

590

stored in 4 bytes, whereas its text version might be “12345”, requiring 5 bytes. Similarly, a float is always stored in 4 bytes, while its formatted version might be “6.02314e13”, requiring 10 bytes.

Our next example shows how an array of integers is written to disk and then read back into memory, using binary format. We use two new functions: write(), a member of ofstream; and read(), a member of ifstream. These functions think about data in terms of bytes (type char). They don’t care how the data is formatted, they simply transfer a buffer full of bytes from and to a disk file. The parameters to write() and read() are the address of the data buffer and its length. The address must be cast, using reinterpret_cast, to type char*, and the length is the length in bytes (characters), not the number of data items in the buffer. Here’s the listing for

BINIO:

//binio.cpp

//binary input and output with integers

//create output stream ofstream os(“edata.dat”, ios::binary);

//write to it

os.write( reinterpret_cast<char*>(buff), MAX*sizeof(int) );

buff[j] = 0;

//create input stream ifstream is(“edata.dat”, ios::binary);

//read from it is.read( reinterpret_cast<char*>(buff), MAX*sizeof(int) );

for(j=0; j<MAX; j++) //check data

Chapter 12

592

Writing an Object to Disk

When writing an object, we generally want to use binary mode. This writes the same bit configuration to disk that was stored in memory, and ensures that numerical data contained in objects is handled properly. Here’s the listing for OPERS, which asks the user for information about an object of class person, and then writes this object to the disk file PERSON.DAT:

//opers.cpp

//saves person object to disk

using namespace std;

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

cout << “Enter name: “; cin >> name; cout << “Enter age: “; cin >> age;

}

};

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

outfile.write(reinterpret_cast<char*>(&pers), sizeof(pers)); return 0;

}

The getData() member function of person is called to prompt the user for information, which it places in the pers object. Here’s some sample interaction:

Enter name: Coleridge

Enter age: 62

The contents of the pers object are then written to disk, using the write() function. We use the sizeof operator to find the length of the pers object.

Chapter 12

594

Notice, however, that while the person classes in OPERS and IPERS have the same data, they may have different member functions. The first includes the single function getData(), while the second has only showData(). It doesn’t matter what member functions you use, since they are not written to disk along with the object’s data. The data must have the same format, but inconsistencies in the member functions have no effect. However, this is true only in simple classes that don’t use virtual functions.

If you read and write objects of derived classes to a file, you must be more careful. Objects of derived classes include a mysterious number placed just before the object’s data in memory. This number helps identify the object’s class when virtual functions are used. When you write an object to disk, this number is written along with the object’s other data. If you change a class’s member functions, this number changes as well. If you write an object of one class to a file, and then read it back into an object of a class that has identical data but a different member function, you’ll encounter big trouble if you try to use virtual functions on the object. The moral: Make sure a class used to read an object is identical to the class used to write it.

You should also not attempt disk I/O with objects that have pointer data members. As you might expect, the pointer values won’t be correct when the object is read back into a different place in memory.

I/O with Multiple Objects

The OPERS and IPERS programs wrote and read only one object at a time. Our next example opens a file and writes as many objects as the user wants. Then it reads and displays the entire contents of the file. Here’s the listing for DISKFUN:

//diskfun.cpp

//reads and writes several objects to disk

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