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