Chapter 5
File I/O
Introduction
Data hierarchy
0 and 1 (bits) –> Charcaters --> field ->Record -> files ->
database
Files:
Is a collection of data that is stored together under a
common name usually on a secondary storage device
E.g. the C++ programs that you store on a disk
Why use files?
Convenient way to deal with large quantities of data
Store data permanently (until file is deleted)
Avoid having to type data into program multiple times
Share data between programs
…introduction
Terminology
Input. Get input from/read a file.
Output. Put data into/write a file
To store and retrieve data on a file in C++ three items
are required:
A file
A file stream
A mode
…introduction
Files are physically stored on an external medium using
a unique name called external file name
Streams is a one way transmission path that is used to
connect a file stored on a physical device to a program.
I/O in C++ uses streams… flow of data into and/or out
of a program
A stream is a data type (like int, double), but with
special properties.
Associated with every file stream is a mode, which
determines the direction of data on transmission path
To and from a file
…introduction
Two file streams based on mode
Input file stream – mode designated as input
Output file stream – mode designated as output
Disk
#include <fstream.h> Output file stream
int main()
{
…. Input file stream
return 0;
}
…introduction
There are two types of streams
Text stream
A text stream is a sequence of characters
character translations may occur as required by the host environment
e.g.a new line may be converted to a carriage return/linefeed pair
may not be a one-to-one relationship between the characters that are written
Binary stream
A binary stream is a sequence of bytes
a one-to-one correspondence to those in the external device
To use files we need to know:
how to "connect" file to program
how to tell the program to read data
how to tell the program to write data
error checking and handling EOF
How to “disconnect” file from program
…introduction
You associate (connect) a stream with a specific file by
performing an open operation
Once a file is open, information can be exchanged
between it and a program – read and write operation
All streams are the same but all files are not
…introduction
You disassociate a file from a specific stream with a
close operation
All files are closed automatically when the program
terminates normally
Files are not closed when a program terminates abnormally
If you close a file opened for output, then contents, if
any, of its associated stream are written to the
external device
This process is referred to as flushing the stream
Each stream that is associated with a file has a file
control structure of type FILE
The standard streams
When program starts execution, three streams are
opened automatically.
stdin -- standard input -- cin
stdout -- standard output -- cout
stderr -- standard error -- cerr
C++ File I/O
To perform file I/O, the header file fstream.h is
required
fstream.h defines several classes, including ifstream,
ofstream, and fstream
ifstream - Can be used for File read/input operations
ofstream - Can be used for File write/output operations
fstream - Can be used for both read/write c++ file I/O operations
These classes are derived form istream, ostream,
istream and ostream are derived form ios
File processing
In file processing, files are generally classified into two as
Text file
its content is treated as a sequence of characters
can be accessed sequentially
E.g. the value int count 321 stored in three byte considering the digit
sequence ‘3’, ‘2’, ‘1’
Binary file
record sequence in a binary format
E.g. the value int count 321 stored in two byte since int requires two
byte to store any of its value
0000 0001 0100 0001
Text File Processing
File processing involves the following major steps
Include fstream.h header file
Declaring file variable identifier
Opening the file
Processing the file
Closing the file when process is completed.
Using Files
1: To access file handling routines:
#include <fstream.h>
2:To declare variables that can be used to access file:
ifstream in_stream;
ofstream out_stream;
3: To open the file
in_stream.open("infile.txt");
out_stream.open("outfile.txt");
4:To see if the file opened successfully:
if (in_stream.fail())
{
cout << "Input file open failed\n";
exit(1); // requires <cstdlib>
}
…Using Files
5: To get data from a file (one option), must declare a variable to hold the data and
then read it using the extraction operator:
int num;
in_stream >> num;
[Compare: cin >> num;]
6:To put data into a file, use insertion operator:
out_stream << num;
[Compare: cout << num;]
NOTE: Streams are sequential – data is read and written in order –
generally can't back up.
7:When done with the file:
in_stream.close();
out_stream.close();
Opening and closing a file
An open file is represented within a program by a stream object
any input or output operation performed on this stream object will be
applied to the physical file associated
In C++, you open a file by linking it to a stream
Before you can open a file, you must first obtain a stream
There are three types of streams
ifstream in ; //input stream
ofstream out ; // output stream
fstream io ; // input and output
Opening
Once you have declared a stream, you associate it with a file
by using the method open().
Prototype
void open (const char *filename, int mode, int access = filebuf::penprot );
The value of the mode determines how the file is opened
E.g
ifstream in_file;
in_file.open(“test.txt”); // open a file named test.txt for input
Opening …
It is good programming practice to check that the
connection has been established successfully before
using it
To check if a file stream was successful opening a file
by calling to member is_open() with no arguments
returns a bool value of true in the case that indeed the
stream object is associated with an open file, or false
otherwise
E.g.
if (myfile.is_open()) { /* ok, proceed with output */ }
ifstream myStream ( "myfile" ); // open file for input
The check can also made by using fail().
Returns true if the open fails false otherwise
E.g
ifstream in_file;
in_file.open(“test.txt”); // open a file named test.txt for input
if(in_file.fail())
{
cout<<“\nThe file was not successfully opened”;
exit(1); //exits the program – stdlib.h
}
When we are finished with our input and output
operations on a file we have to close it using close()
its resources become available again
E.g. myfile.close();
Mode Description
ios::app Write all output to the end of the file
ios::ate Open a file for output and move to the end of the file
(normally used to append data to a file). Data can be
written anywhere in the file.
ios::binary Cause the file to be opened in binary mode.
ios::in Open a file for input
ios::nocreate If the file does not exist, the open operation fails.
ios::noreplace If the file exists, the open operation fails.
ios::out Open a file for output
ios:trunc Discard the file's content if it exists (this is also the
default action ios::out)
ofstream, ifstream and fstream has a default mode
class default mode parameter
ofstream ios::out
ifstream ios::in
fstream ios::in | ios::out
Reading and Writing Text Files
Simply use the << and >> operators
same way you do when performing console I/O
except that instead of using cin and cout, you substitute
a stream that is linked to a file
E.g.
ofstream out ("inventory"); //ofstream out;
//out.open(“inventory”)
out <<"Radios" << 39.95 << endl;
out << "Toastors" << 19.95 << endl;
out.close ( );
#include <iostream.h>
#include <fstream.h>
int main () {
ofstream myfile;
myfile.open ("example.txt");
myfile << "Writing this to a file.\n";
myfile.close();
return 0;
}
This code creates a file called example.txt and inserts
a sentence into it in the same way we are used to do
with cout, but using the file stream myfile instead.
Example 2: writing on a text file
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
ofstream myfile ("example.txt");
if (myfile.is_open())
{
myfile << "This is a line.\n";
myfile << "This is another line.\n";
myfile.close();
}
else
cout << "Unable to open file";
return 0;
}
Example 3: reading a text file
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main ()
{
string line;
ifstream myfile ("example.txt");
if (myfile.is_open())
{
while (! myfile.eof() )
{
getline (myfile,line);
cout << line << endl;
}
myfile.close();
}
else cout << "Unable to open file";
return 0;
}
Checking state flags
•There are functions that check the state of a stream with bool return type
Function Description
bad() Returns true if a reading or writing operation fails. For
example in the case that we try to write to a file that is not
open for writing or if the device where we try to write has
no space left.
fail() Returns true in the same cases as bad(), but also in the
case that a format error happens, like when an
alphabetical character is extracted when we are trying to
read an integer number.
eof() Returns true if a file open for reading has reached the end.
good() It is the most generic state flag: it returns false in the same
cases in which calling any of the previous functions would
return true.
If the file can support position requests
opening that file also initializes the file position indicator to the start of the
file
each character is read from or written to the file, the position indicator is
incremented
ifstream, like istream, has a pointer known as the get pointer
that points to the element to be read in the next input
operation.
ofstream, like ostream, has a pointer known as the put pointer
that points to the location where the next element has to be
written.
Finally, fstream, inherits both, the get and the put pointers,
from iostream (which is itself derived from both istream and
ostream
Internal stream pointers that point to the reading or
writing locations
tellg()
return a value of the member type pos_type, which is an
integer data type representing the current position of the get
stream pointer
tellp()
return a value of the member type pos_type, which is an
integer data type representing the current position of the the
put stream pointer
