Chapter four

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
 Cont….
• 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
 Cont….
• 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
 Cont….
• Two file streams based on mode
– Input file stream – mode designated as input
– Output file stream – mode designated as
output
Disk
#include <fstream.h> input file stream
int main()
{
…. Output file stream
return 0;
}
 Cont….
• 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
 Cont….
• 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
 Cont….
• 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
 Cont….
• This structure FILE is defined in the header
stdio.h
• The File Pointer
– is a pointer to information that defines various
things about the file:
• name
• status
• the current position
• A file pointer is a pointer variable of type FILE.
– FILE * fp;
 The standard streams

• When program starts execution, three

streams are opened automatically.
– stdin --- standard input -- cin
– stdout -- standard output -- cout
– stderr -- standard error
 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
– 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>

2: To declare variables that can be used to access file:

ifstream in_stream;
ofstream out_stream;

3: To connect your program's variable (its internal name) to an external

file (i.e., on the Unix file system):
in_stream.open("infile.dat");
out_stream.open("outfile.dat");

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
 Cont..
• 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 opend”
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::noreplac If the file exists, the open operation fails.

e

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)
 Cont…
• 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.
#include <iostream.h>
#include <fstream.h>
#include <string.h>

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;
}
• reads a text file and prints out its content on the screen
 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.
 Cont….
• 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
 Cont…
• 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
 Cont…
• ios::beg
• offset counted from the beginning of the
stream
• ios::cur
• offset counted from the current position of
the stream pointer
• ios::end
• offset counted from the end of the stream
# include <ftream.h>
# include <stdlib.h>
int main()
{
char ch;
long offset, last;
ifstream in_file(“test.txt”);
if(in_file.fail())
{
cout<<“\nThe file was not successfully opened”
exit(1);
}
in_file(seekg(oL, ios::end); // move to the end of the file
last= in_file.tellg(); // save the offset of the last character
for(offset =1L;offset<=last;offset++)
{
in_file.seek(-offset,ios::end);
ch=in_file.get();
cout<<ch<<“:”;
}
in_file.close();
return 0;
}
 Binary File Processing
• To perform binary operations on a file, it should be opened
using the ios::binary mode specifier.
• functions specifically designed to input and output binary
data sequentially
– read ( memory_block, size );
– write ( memory_block, size );

• memory_block is of type "pointer to char" (char*)

• It represents the address of an array of bytes where
– the read data elements are stored
– from where the data elements to be written are taken
• size is an integer value that specifies the number of
characters to be read or written from/to the memory block
• There are other two functions - get ( ) and put ( )
 get() and put()
• byte-oriented
– get ( ) will read a byte of data.
– put ( ) will write a bye of data.
• E.g
– istream & get( char & ch );
• read a single character from the associated stream
and puts the value in ch, and returns a reference to
the stream
– ostream & put ( char ch);
• writes ch to the stream and returns a reference to the
stream
• char in; • ofstream out ( "chars",
ifstream in ( "test", io::out | ios::binary);
ios::in | ios::binary); for (int i= 0; i < 256; i++)
if (!in) out.put ( (char ) i ) ;
{ //write //all characters to
cout <<"Cannot open file"; disk
return 1; out.close ( );
}
while (in) //inn will be //0
when eof is reached
{
in.get ( ch );
cout << ch;
}
 Cont..
• istream &get (char *buf, int num, char
delim = '\n');
• istream & getline ( char *buf, int num, char
delim ='\n');
# include <iostream.h> file.seekg (0, ios::beg);
# include <fstream.h> file.read (memblock, size);
ifstream::pos_type size;
char * memblock; file.close();
int main () cout << "the complete file
{ content is in memory";
ifstream file ("example.txt", delete[] memblock;
ios::in|ios::binary|ios::ate); }
if (file.is_open()) else cout << "Unable to
{ open file";
size = file.tellg(); return 0;
memblock = new char }
[size];
 Thank you

Chapter contents end!!!