CPS120: Introduction to Computer Science

Lecture 15 B

Data Files

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.

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.

Sequential Files

• Stores data as one long continuous piece of data• Each different element is stored next to the prior

piece of element• There are no "empty bytes" of disk space in

between consecutive pieces of data• To access a specific record (piece of data), though,

the C++ program must read through all of the former pieces of data

Random-Access Files

• A random-access external data file stores data into blocks of memory of equal size

• This may waste some disk space, it does speed up access times.

An Analogy

Sequential-access data files compare to audio cassette tapes ASrandom-access data files compare to audio compact discs (CD's)

Opening and Closing Data Files

• Files must be officially be opened before they are used by a C++ program

• 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

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

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

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");

Using Sequential Files

• A sequential access file cannot be opened for input and output at the same time

• You cn close a file that was opened for input and reopen it for output during a program's execution

Closing Files

• 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();

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";}

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.

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.

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

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( ) );

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");

Sequential Read / Write

• One disadvantage to using sequential-access files is that it is tedious to insert data in the middle

• 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

Prompting for File Names

• Using the c_str function with a string variable, you can ask the user to input the file to be opened and store that filename in a string variable. Then, you can open the file. For example,string fileName; // user's input

ifstream infile; // the file for input

cin >> fileName; // getting user's inputted filename

infile.open(filename.c_str()); // opening the file for input

Standardized File Handling

• In order to standardize file handling, many modern operating systems include their own set of file handling functions that programmers can use. – Microsoft Windows programmers can use

predefined funtions from the Microsoft Foundation Class library (MFC library), a C++ implementation of the Windows application programming interface (API).