FILE HANDLING IN

C++
Files (Streams)

 Files are used to store data in a relatively

permanent form, on floppy disk, hard disk,
tape or other form of secondary storage. Files
can hold huge amounts of data if need be.
Ordinary variables (even records and arrays)
are kept in main memory which is temporary
and rather limited in size. The following is a
comparison of the two types of storage:
 Main memory Secondary memory
 Made up of RAM chips.  Usually a disk drive (or magnetic
 Used to hold a program tape).
when it is running,  Used to hold files (where a file
including the values of its can contain data, a program, text,
variables (whether integer, etc.)
char, an array, etc.)
 Can hold rather large amounts of
 Can only hold relatively data.
small amounts of data.
 Is fairly permanent. (A file
 Is temporary (as soon as remains even if the power goes
the program is done or the out. It will last until you erase it,
power goes out all of these as long as the disk isn't damaged,
values are gone). at least.)
 Gives fast access to the • Access to the data is considerably
data (all electronic). slower (due to moving parts).
C++ STREAMS
 A Stream is a general name given to flow of
data.
 Different streams are used to represent
different kinds of data flow.
 Each stream is associated with a particular
class, which contains member functions and
definitions for dealing with that particular
kind of data flow.
Flow of Data….

Data
PROGRAM

Input
Output
Stream
Stream
>>
DEVICES OR <<
(Extraction
(Insertion
operator) FILES operator)
Data
istream class ostream class
The following classes in C++
have access to file input and
output functions:
 ifstream
 ofstream
 fstream
The Stream Class Hierarchy
NOTE : UPWARD ARROWS INDICATE
THE BASE CLASS

ios

istream fstreambase ostream

get() put()
getline() write()
read() iostream <<
>>

Ifstream Ofstream
fstream
Open() Open()
Tellg() Tellp()
Seekg() Seekp()
DIFFERENT FILE OPERATIONS

 OPENING A FILE
 CLOSING A FILE
 READING FROM A FILE
 WRITING ON A FILE
 CHECKING FOR END OF FILE
OPENING A FILE
(Associating a stream with a file)

1. By using the CONSTRUCTOR of the

stream class.
ifstream transaction(“sales.dly”);
ofstream result(“result.02”);
2. By using the open() function of the stream
class
ifstream transaction;
transaction.open(“sales.dly”);
File Mode Parameters
PARAMETER MEANING
 Ios::app Append to end-of file
 Ios::ate goto end of file on opening
 Ios::binary binary file
 Ios::in Open existing file for reading
 Ios::nocreate open fails if file doesn’t exist
 Ios::noreplace open fails if file already exists
 Ios::out creates new file for writing on
 Ios::trunc Deletes contents if it exists

The mode can combine two or more modes using bit wise
or ( | )
Checking For Successful File Opening

ifstream transaction(“sales.dly”);
if (transcation == NULL)
{
cout<<“unable to open sales.dly”;
cin.get(); // waits for the operator to press any key
exit(1);
}
Closing of File

Stream_name.close();
e.g., transaction.close();
Types of Files

 . The two basic types are

– text and
– binary.
 A text file consists of readable characters
separated into lines by newline characters. (On
most PCs, the newline character is actually
represented by the two-character sequence of
carriage return (ASCII 13), line feed (ASCII 10).
 A binary file stores data to disk in the same form in which
it is represented in main memory.
 If you ever try to edit a binary file containing numbers you
will see that the numbers appear as nonsense characters.
Not having to translate numbers into a readable form
makes binary files somewhat more efficient.
 Binary files also do not normally use anything to separate
the data into lines. Such a file is just a stream of data with
nothing in particular to separate components.
 When using a binary file we write whole record data to
the file at once. When using a text file, we write out
separately each of the pieces of data about a given
record.
 The text file will be readable by an editor, but the
numbers in the binary file will not be readable in this
way.
 The programs to create the data files will differ in how
they open the file and in how they write to the file.
 For the binary file we will use write to
write to the file, whereas for the text file we
will use the usual output operator(<<) and
will output each of the pieces of the record
separately.
 With the binary file we will use the read
function to read a whole record, but with
the text file we will read each of the pieces
of record from the file separately, using the
usual input operator(>>)
EXAMPLES
 Creation of a text file
: Types of File Access

Sequential access. With this type of file

access one must read the data in order,
much like with a tape, whether the data
is really stored on tape or not.

Random access (or direct access). This

type of file access lets you jump to any
location in the file, then to any other,
etc., all in a reasonable amount of time.
FILE POINTERS
FILE POINTERS
 Each file object has two integer values
associated with it :
– get pointer
– put pointer
 These values specify the byte number in the
file where reading or writing will take
place.
File pointers…..
 By default reading pointer is set at the
beginning and writing pointer is set at the end
(when you open file in ios::app mode)

 There are times when you must take control

of the file pointers yourself so that you can
read from and write to an arbitrary location in
the file.
Functions associated with file
pointers :

 The seekg() and tellg() functions allow you

to set and examine the get pointer.

 The seekp() and tellp() functions allow you

to set and examine the put pointer.
seekg() function :
 With one argument :
seekg(k) where k is absolute position from
the beginning. The start of the file is byte 0
File End
Begin

k bytes ^
File pointer

The seekg() function with one argument

seekg() function :
With two arguments :
the first argument represents an offset from a particular
location in the file.
the second specifies the location from which the offset is
measured.

Begin End

^
Offset from Begin

The seekg() function with two argument

seekg() function :
With two arguments :
Begin End

^
Offset from Begin

^
Offset from end

^
Offset from current
position
The seekg() function with two argument
//
//clrscr();
getch();
#include <fstream.h> cout <<"reading from created file \n";
#include <conio.h> infl.open("try.txt");
#include <stdio.h> out.open("cod.dat");
void main() //**********************************
{
c=infl.get();
//clrscr(); do
char c,d,ans; { d=c+1;
char str[80]; cout<<c<<d<<'\n';
ofstream outfl("try.txt"),out("cod.dat"); out.put(d);
c= infl.get();
ifstream infl;
}
do while (c!='\0');
{ cout<<"please give the string : "; out<<'\0';
gets(str); infl.close();
outfl<<str; outfl.close();
getch();
cout <<"do you want to write more...<y/n> : ";
//*********************************
ans=getch(); }
}
while(ans=='y');
outfl<<'\0';
outfl.close();