and a picture of the results might look as follows:

DRAW

If you review the input-output inheritance structure found in Figure 11.2 above, you will see that 'ofstream' is a class name. Therefore, what we are doing here is calling the constructor for this class to instantiate an instance called 'outputData'. We can use any name we want for this instance - including 'cout', but that would not be adviseable since you would then lose access to the 'built-in' cout.

The file name inside the parameters,that is "person.dat", is passed to the constructor which uses it to make the connection to a file with the same name. If no such file exists, by default one will be created. Exactly where in the directory structure that file is created depends on the compiler you are using and the options you have set. Also, there are additional, optional parameters one can use in the constructor to control if and how the file is created, but that is beyond the scope of this text. Check the "Essentials of C++" for more details.

Now that we have our new stream, we need to use it. In other words, we need to send output to it. In the above code, we sent the output to 'cout' so all we need to do is change all the "cout's" to 'outputData'. Here is the code put in the form of a file complete with main and the necessary 'include' statements.

// Basic File Handling
// File: fileio1.cpp

#include <iostream.h>
#include <iomanip.h>

#include <fstream.h>

void main()
{	ofstream outputData ("person.dat");

outputData << setiosflags(ios::fixed);
outputData << setprecision(2);

	outputData << setw(30) << setiosflags(ios::left) << "Name"
		   << setiosflags(ios::right)
		   << setw(16) << "Phone Number"
		   << setw(6)  << "Age" << setw(10) << "Height" << endl;

	outputData << setw(30) <<  setiosflags(ios::left) << "Curtis"
		   << setiosflags(ios::right)
		   << setw(16) << "505-454-3302"
		   << setw(6)  << 6 << setw(10) << 5.75 << endl;

	outputData << setw(30) << setiosflags(ios::left) << "Fred Smith"
		   << setiosflags(ios::right)
		   << setw(16) << "505-454-3302"
		   << setw(6)  << 102 << setw(10) << 5.128<< endl;
}

This time we work with the class 'ifstream', also declared in the header file 'fstream.h'. The variable identifier 'inputData' is the name for the instance of the stream we are creating, and 'person.dat' is again the file name passed as a parameter to the class constructor. With the output file it made little difference what file name we provide because the system would create a new file if one did not already exist. Indeed, the only concern we might have had was to make sure we did not overwrite a file we wanted to keep. The input file is just the opposite. Now we must make sure that the name we provide matches exactly the name of the file that holds the data we want to read in. Since we wrote the data to 'person.dat', that is the file we read from.

Clearly, it is possible to make a mistake and request a file that does not exist. The file may never have been created; it may be in a different directory; or it may have been accidentally deleted. If the file does not exist and we do not tell the system what else to do in this case, the program will still continue - with the input requests being ignored because the file has a 'fail' status. Thus, it is always wise to code in a check to see if the input file was successfully opened. Here is the code for this:

ifstream inputData ("person.dat");
if (!inputData)
{

cout << "Cannot open input file\n";
exit(1);

}

This means:

1. call the member function 'fail' associated with the instance 'inputData' of the class 'ifstream';

2. Since 'fail' returns TRUE if a failure has occurred, the code will execute the code inside the 'if' statement if a failure has occurred.

This instruction tells the system to skip up to and including the first newline character it encounters or to skip 133 characters - whichever comes first. Now, where does '133' come from? We could have counted exactly how many characters there are in the heading but that is a hassle and besides what if we change the heading. In one sense the number '133' is arbitrary - big enough to make sure we skip enough characters - but it also reveals that the coder has been around for awhile - to say the least. Since printers tend to print either 80 characters plus 1 control character or 132 characers plus one control character, back in the days when almost all output was sent to a printer, the values 81 and 133 were important.

Anyway, with this line executed, the file pointer is pointing to the first character on the first line of actual data (the second line of the file), and it is time to read in the name of the first person in the file. Think of the 'file pointer' as an indicator of where in the file the next input is to come from. There isn't really a pointer in the sense that we used pointers earlier in this text. It is more of an image. One can also think of it as the first unread data in the input stream.

Notice that we use the member function 'get' instead of writing "inputData >> name;". Names, of course, are usually in multiple parts separated by blanks, and, as we know, '>>' stops at the first blank. If we had used the '>>' operator, we would have only read in the first name. Not only would the variable name have had an incomplete value, but, when we went to read in the telephone number, we would have, instead, read in the rest of the name because that is where the file pointer would have been pointing. Because we know that the output produced a block of 30 characters via the 'setw(30)' manipulator, we use the same value of 30 in the 'get' function.

Just to show that the '>>' operator can be used (where appropriate), we use it to read in the phone number - which does not contain any blanks. Of course, we had better, then, make sure that those who input telephone numbers do so correctly. The whole issue of data validation is complex and somewhat tedious, not a good topic for discussion here where the goal is to simply give you an overview of file processing. In this case, it might have been better to stick with the 'get' function to avoid this potential problem.

Next, we use the '>>' operator to read in the age and height. The 'get' function would not have worked here because it expects to read in and process characters but we want to process an integer and a double.

Finally, we need to skip past the newline character at the end of the line. We, therefore, declare a string variable 'dummy' to hold this character when it is read in and use 'getline' to read it and skip to the next data line. (The function 'getline' expects a string as its first parameter so we declared 'dummy' to be a string instead of a char even though the newline character ('\0') is really only one character.) All this provides a hint at the need to adapt ones input code to exactly match the structure of the file holding the data.

The rest of the code simply outputs the information, using variables instead of constants, and then repeats the same process for the second line. Had this been a real program, where we did not know how many data lines there were in the file, we would have coded this as a while loop with a stopping condition that tested for the end of the file. We will explore that in the next section when we work with the Contract program.

C. Entering File Names
Before we get to that, however, there is one other issue. As coded, if we want to use different files for input or output on different occasions, we need to modify the actual code for each new file name and recompile the program. It would be much better if the program asked the user for the names of the input and output files. And, now that we know how to read in strings, that is easy to do.

One way to accomplish this is to declare a function to ask the user for the name of a file. This function will receive a prompt string (so that we can use it both to request the input and output files) and return the file name. Here is the definition for this file:

void GetFileName(String prompt, String fileName)
{

cout << endl; // just to make space
cout << prompt << endl;
cin.getline(fileName, 40);

}

Top of Section

Main Menu

Next Section