1. CPS120: Introduction to Computer Science
Data Files

2. Working with Data Files
It is possible to have a C++ program read and use a data file that is stored on your PC's hard drive
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.

3. Using External Files
External data files are simply text files (usually with the extension .txt or .dat) 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 or network
You will have to supply the path of those files in order to successfully access them.

4. Sequential Files Stores data as one long continuous piece of data
To access a specific record (piece of data), though, the C++ program must read through all of the former pieces of data

5. Opening and Closing Data Files
Files must be officially be opened before they are used by a C++ program

6. Required Compiler Directives
Any program that uses file pointers must include the fstream.h header file with the compiler directive, #include <fstream.h> at the top of the program

7. Preparing to Use Files Opening a sequential-access file
ofstream outfile;
ofstream is a C++ keyword indicating the type of pointer that you created
outfile is simply the programmer's chosen name for the file pointer (and can be any valid name)
Open the file "mydata.txt" that is stored on your PC's hard drive
outfile.open("mydata.txt", ios::out); or the shorter version outfile.open("mydata.txt");
output (out) is the default type of access for ofstream objects

8. Reading From a File Declare a file pointer as an ifstream object with:
ifstream infile;
ifstream is a keyword and infile is the name for the file pointer.
Open the actual file for reading with:
infile.open("mydata.txt", ios::in); or the shorter version infile.open("mydata.txt");
// numread.cpp
// This program reads numbers from a data file until zero is encountered.
// Then the program reports the sum and average of the numbers.
#include<fstream.h> // necessary for file I/O
#include<iostream.h>
#include<iomanip.h>
int main() {
float x, sum;
int count;
ifstream infile; // declares file pointer named infile
infile.open("floats.dat",ios::in); // open file for input
sum = 0.0; // initialize sum
count = 0; // initialize count
if (infile) // If no error occurred while opening file
{ // input the data from the file.
cout << "The numbers in the data file are as follows:\n"
<< setprecision(1); // set display to one decimal point
cout.setf(ios::fixed); // prevent numbers from appearing in E-notation
do // read numbers until 0.0 is encountered
infile >> x; // get number from file
cout << x << endl; // print number to screen
sum = sum + x; // add number to sum
count++; // increment count of how many numbers read
} while(x != 0.0);
// Output sum and average.
cout << "The sum of the numbers is " << sum << endl;
cout << "The average of the numbers (excluding zero) is "
<< sum / (count - 1) << endl; }
else // If error occurred, display message.
cout << "An error occurred while opening the file.\n";
infile.close(); // close the output file
int getint;
cin >> getint;
return 0;

9. Using Sequential Files
A sequential access file cannot be opened for input and output at the same time
You can close a file that was opened for input and reopen it for output during a program's execution

10. Closing Files infile.close();
It is very important to always officially close a file, when you are finished using it from within a C++ program.
The following statement would close the file, which is pointed to by the file pointer infile
infile.close();

11. Preparing to Write Output
It is wise to check to make sure that there wasn't an error actually opening the data file
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"; }
// loopwrite.cpp
//This program stores numbers entered by the user until a zero is entered
#include <iostream.h>
#include <fstream.h>
int main() {
float x; // variable for user input
ofstream outfile; // declares file pointer named outfile
outfile.open("floats.dat", ios::out); // open the file floats.dat for output
if (outfile)
cout << "Enter a series of floating-point numbers "<< endl;
cout << "separated by a space or a tab. "<< endl;
cout << "Enter a zero at the end of the series \n";
do //repeat the loop until user enters zero
cin >> x; // get number from the user
outfile << x << endl; // write the number to the file
} while ( x!= 0.0); }
else
cout << "Error opening file. |n";
outfile.close(); // close the output file
return 0;

12. Writing Output
To write data to a sequential-access data file you would use a statement like:
outfile << "John Doe" << endl;
to print that name to the next line in the data file pointed to by the file pointer, outfile.
Open filewrit.cpp
#include<iostream.h>
#include<fstream.h> // necessary for file i/O
int main() {
char user_name[25];
int age;
ofstream outfile; // declares file pointer named outfile
cout << "Enter your name: "; // get name from user
cin.get(user_name, 25);
cout << "Enter your age: "; // get age from user
cin >> age;
outfile.open("NAME_AGE.DAT", ios::out); // open file for output
if (outfile) // if no error occurs while opening file
{ // write the data to the file
outfile << user_name << endl; // write the name to the file
outfile << age << endl; // write the age to the file }
else // If error occurred, display message.
cout << "An error occurred while opening the file.\n";
return 0;

13. Reading Data From Files
Use the insertion operator (>>). But, instead of using the cin keyword, you use the file pointer name that you declared.
infile >> x;
This statement stores the next numeric value in the file pointed to by the file pointer, infile, into the variable, x.
// strread.cpp
// This program reads bot the name and age from the file as strings and converts age
// to an integer
#include<fstream.h> // necessary for file I/O
#include<iostream.h>
#include<stdlib.h> // necessary for atoi function
int main() {
char user_name[25];
char user_age[4];
int age;
ifstream infile; // declares file pointer named infile
infile.open("NAME_AGE.DAT",ios::in); // open file for input
if (infile) // If no error occurred while opening file
{ // input the data from the file.
infile.get(user_name,25); // read the name from the file
infile.ignore(80,'\n');
infile.get(user_age,4); // read the age from the file as a string
age = atoi(user_age);
cout << "The name read from the file is " << user_name << ".\n";
cout << "The age read from the file is " << age << ".\n"; }
else // If error occurred, display message.
cout << "An error occurred while opening the file.\n";
infile.close(); // close the input file
return 0;

14. Appending Data
Adding data to the end of a sequential-access data file is called appending
Open the file using the ios::app stream operation mode as in:
outfile.open("myfile.txt", ios::app);
where the app is short for append.
If you accidentally open the file with the ios::out mode, you will end up overwriting data in the file because C++ will write the first piece of outputted data at the beginning of the sequential-access data file
// fileapp.cpp
// this program adds data to the end of the data file,
// rather than replacing whatever data was in the file.
#include<iostream.h>
#include<fstream.h> // necessary for file i/O
int main() {
char user_name[25];
int age;
ofstream outfile; // declares file pointer named outfile
cout << "Enter your name: "; // get name from user
cin.get(user_name, 25);
cout << "Enter your age: "; // get age from user
cin >> age;
outfile.open("NAME_AGE.DAT", ios::app); // open file for appending
if (outfile) // if no error occurs while opening file
{ // write the data to the file
outfile << user_name << endl; // write the name to the file
outfile << age << endl; // write the age to the file }
else // If error occurred, display message.
cout << "An error occurred while opening the file.\n";
return 0;

15. Detecting 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. do {
infile >> x;
if ( !infile.eof( ) )
cout << x << endl; }
} while ( !infile.eof( ) );
// readEOF.cpp
// This program continues to read floating point numbers from a file until the
// EOF is reached
#include<fstream.h> // necessary for file I/O
#include<iostream.h>
#include<iomanip.h> // necessary for setprecision manipulator
int main() {
float x; // Declare variable used for input.
ifstream infile; // Declare file pointer named infile.
infile.open("PRICES.DAT",ios::in); // Open file for input.
if (infile) // If no error occurred while opening file,
{ // input the data from the file.
cout << "The prices in the file are: \n" << setprecision(2);
do // Loop while not the end of the file.
infile >> x; // Get number from file.
if (!infile.eof())
{ // If not the end of file,
cout << x << endl; // print the number to the screen. }
} while (!infile.eof());
else // If error occurred, display message.
cout << "An error occurred while opening the file.\n";
infile.close(); // Close the input file.
return 0;

16. Using Multiple Data Files
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");
outfile.open("outputfile.txt");