Wyo C++ Ch. 11 Notes

Objective #1: Understand the uses for data files.

• Rarely, does a program work without relatively large amounts of data. Rather than requiring the user to input large amounts of data, one often "reads" data from an external data file. That is, it is possible to have a C++ program read and use a data file that is stored on your PC's hard drive. For example, a video game that displays a list of high scores of past players relies on such file operations. The video game program will open and read a file that stored on the hard drive in order to display the list of high scorers. It would be awkward and actually impossible to expect future players to know what the past high scores were and to have the player input them through a keyboard.
  
  
• Often, external data files are simply text files (usually with the extension .txt) that are stored in the same folder as the C++ program which access them. It is possible to have a C++ program read files that are stored anywhere else on your PC's hard drive but you will have to supply the path of those files in order to successfully access them.

Objective #2: Understand the difference between sequential-access and random-access data files.

• A sequential-access file stores its data as one long continuous piece of data. Each different element is stored next to the prior piece of element. This may save space since there are no "empty bytes" of disk space in between consecutive pieces of data. In order to access a specific record (piece of data), though, the C++ program must read through all of the former pieces of data before it recognizes the desired record. This process of reading possibly large amounts of irrelevant data can take a lot of processor time.
  
  
• A random-access data file stores data into blocks of memory of equal size. That is, 8 bytes of disk space may be used for one record such as "encyclopedia" but then 8 bytes of disk space would also be used to store the record, "a". While this may waste some disk space, it does speed up access times.
  
  
• Word processor programs (like MS Word and WordPerfect) and spreadsheet programs (like MS Excel) often store data in sequential-access data files. Database programs (like MS Access and FileMaker Pro) usually store data in random-access data files.
  
  
• An analogy:

  Sequential-access data files : audio cassette tapes
                                   AS
  random-access data files : audio compact discs (CD's)

Objective #3: Open and close data files.

• Files must be officially be opened before they are used by a C++ program. This does not cause MS Word, for example, to launch and actually open a text file on your PC. To open a sequential-access file, you must first declare a file pointer that you intend to point to the file that you will open. The following statement could be used to declare a file pointer:

  ofstream outfile; 

  Where ofstream is a C++ keyword indicating the type of pointer that you created and outfile is simply the identifier (i.e. variable name) for the file pointer that you want to declare. You could use any legal identifier name instead of outfile in this example.

  The file pointer declaration statement above however only declares the file pointer. It does not actually open a file from your computer's hard drive. To actually open a file, you can use the statement
  
  ofstream outfile("mydata.txt"); 
  
  which declares outfile as an ofstream file pointer object AND connects the file pointer to the actual file mydata.txt that is saved in the same folder as your C++ source file.
  
  Note that you can use the open function to make this connection between the file pointer and the actual file. So the following two statements are actually equivalent to the last statement above.
  
  ofstream outfile;
  outfile.open("mydata.txt");
  
  and you can even specifiy the file stream mode to be output by using the statement:
  
  outfile.open("mydata.txt", ios::out);
  
  but since the outfile pointer is an ofstream object, C++ does not need to have the ios::out argument in the open function call.
  
  Having opened the mydata.txt file with the outfile file pointer, your C++ program can now write store data to that file. Storing data to a file is called "writing to a file."

  In order to be able to read data from a sequential-access file, you need to use an ifstream file pointer rather than an ofstream file pointer. The following examples could be used to to open a file for input rather than output. Note that we use the more logical file pointer name infile rather than outfile.

  ifstream infile("mydata.txt");
  
  or
  
  ifstream infile;
  infile.open("mydata.txt", ios::in);
  
  but the last statement could be replaced by the simpler
  
  infile.open("mydata.txt");
  
  

• It is very important to close a file that has been opened for either input or output. You should close the file after you are finished using it in your program. Closing a file essentially means that you are breaking the connection between the file pointer and the actual file. To close a file you simply use the close function with the file pointer as in:
  

  infile.close();
  
  or perhaps
  
  outfile.close();
  
  Do not type the name of the file in the parentheses.

Objective #4: Write to data files.

• To write data to a sequential-access data file, you do not use the cout stream operator like you would to direct output to the monitor screen. Rather, you simply would use a statement like:

  outfile << "John Doe";

  to print that name to the next line in the data file pointed to by the file pointer, outfile.

  It probably would be wise though to use the statement,

  outfile << "John Doe" << endl;
  
  or
  
  outfile << "John Doe" << '\n';

  so that a new-line character were placed there and the next piece of data to be written to the file would not butt up against the 'e' in "Doe".

  It is also wise to first check to make sure that there wasn't an error actually opening the data file so one can use an if statement like the following to protect the program from crashing.

  if (outfile)         // same as if (outfile != 0)
      {
         outfile << "John Doe" << endl;
      }
  else
      {
          cout << "An error occurred while opening the file.\n";
      }

Objective #5: Read from data files.

• After you have opened an external data file for input, your C++ program can read data from that file. You can think of this as inputting data into your C++ program from the file stream rather than having the user input data into the standard input stream (cin) via the keyboard.
  
  
• When you wish to read numeric data, you can use the input operator >> (aka extraction
• operator). But, instead of using the cin keyword, you use the file pointer name that you declared.

  infile >> num;
  
  instead of
  
  cin >> num;

  This statement stores the next numeric value in the file pointed to by the file pointer infile into the variable num.

• You can also read data from a file into an apstring variable using the input operator >> as in
  
  infile >> firstName;
  
  
• However, if the first record (i.e. line) of the sequential access file has one or more spaces in it, the input operator >> will not read the whole line and store it into the variable. The >> operator stops reading data at the first blank space or end of line character (i.e. \n). If you want to store a line of data that includes spaces into a string variable, you must use the apstring function getline as in
  
  getline(infile, firstName);
  
  where the first argument is the stream from which you wish to obtain the data and the second argument is the apstring variable into which you want to store that data. Note that you could use the statement,
  
  getline(cin, firstName);
  
  to allow the user to enter their name "John Doe" into the keyboard (standard input stream, cin) and store that whole name into the apstring variable firstName.

Objective #6: Add to the end of a data file.

• A file is treated as a stream in C++. Think of a file as information that either flows into your C++ program (i.e. reading from a file) or think of your program as sending a stream of information to a file (i.e. writing to a file.) There are three important stream operation modes (or stream access modes) to be aware of when working with files: input, output, and append. You have already been introduced to the input and output modes above.
  
  

• When you open a file for output using the output access mode, any data that is written to the file overwrites the first record of the file. In the case of a sequential access file rather than a random access file, the first record of the file is the first line. Often however, it is desirable to add data to the end of an existing sequential access file rather than to have existing data overwritten. To do this you must open the file in the append stream access mode. This process is called appending to the file. To open the file using the ios::app stream operation mode, you must use an ofstream file pointer and then use open function with that file pointer as in:

ofstream appendFile;
appendFile.open("mydata.txt", ios::app);

rather than

appendFile.open("mydata.txt");

or

appendFile.open("mydata.txt", ios::out);

Objective #7: Detect the end of a file.

• Use the eof function to determine whether the end of a sequential-access file has been reached. This function returns a 1 (true) if an attempt has been made to read past the end of the file.
  
  
• Use the eof function in this manner:

do
{
    infile >> x;

    if ( !infile.eof( ) )
    {
            cout << x << endl;
    }

} while ( !infile.eof( ) );

Objective #8: Use multiple data files at the same time and insert data into the middle of a sequential access file.

• For one C++ program to access multiple data files, you simply have to create multiple file pointers (each one pointing to a different data file). For example,
  
  infile.open("inputfile.txt", ios::in);
  outfile.open("outputfile.txt", ios::out);
  
  uses two file pointers, infile and outfile. Infile points to the external data file inputfile.txt, which contains data that will be read into the C++ program. Outfile points to the external data file outputfile.txt, which will be written to by the C++ program.
  
  
• One disadvantage to using sequential-access files is that it is tedious to insert data in the middle of the file (even though it is easy to append to the end of such files.) The common method is to open the file and read each line, one at a time. As you read each line, you write the information into a new, blank file that is opened for output. When you reach the point at which you wish to insert new information, you simply write that information to its proper place in the new, second file. Then, continue to read each line from the first file and copy it to the second file.

Objective #9: Prompt the user for file names.

• You can ask the user to input the file to be opened and store that filename into an apstring variable. Then, you can open the file. But you must use the c_str function with the apstring variable. For example,
  
  apstring fileName;          // user's input
  ifstream infile;             // the file for input
  
  cin >> fileName;         // getting the user's inputted filename
  
  infile.open(fileName.c_str(), ios::in);      // opening the file for input
  
  
• The apstring c_str function converts apstring variables into built-in C++ character arrays. It is necessary to use the c_str function here because the open function only works with built-in C++ character arrays as arguments and not apstring variables.

Objective #9: Pass file stream objects as parameters to functions.

• You can pass a stream object to a function as a parameter. The type that you use in the function header and function prototype is istream to pass an input stream object and ostream to pass an output stream object.
  
  
• The following program uses a function (myFunc) to read an integer from a file that is already opened for input. The number read from the text file is displayed by the main function after it is returned from myFunc.
  
  #include <iostream.h>
  #include <fstream.h>

  int myFunc(istream &);

  int main()
  {
     ifstream infile("junk.txt");
  
     cout << myFunc(infile) << endl;

     return 0;
  }// end of main

  int myFunc(istream &myfile)
  {
     int num = 0;
     myfile >> num;
     return num;
  }
  
  

• Note the use of istream (not ifstream) as the type used in the function's header. Notice that the stream is passed by reference and the & operator is used in the function header and prototype as well.