Professional Documents
Culture Documents
19 File Handling
19 File Handling
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
1. Made up of RAM chips.
Secondary memory
1. Usually a disk drive (or magnetic tape).
2. Used to hold a program when it 2. Used to hold files (where a file is running, including the values of can contain data, a program, text, its variables (whether integer, char, etc.) an array, etc.)
3. Can only hold relatively small 3. Can hold rather large amounts of amounts of data. data. 4. Is temporary (as soon as the 4. Is fairly permanent. (A file program is done or the power goes remains even if the power goes out. out all of these values are gone). It will last until you erase it, as long as the disk isn't damaged, at least.) 5. Gives fast access to the data (all 5. Access to the data is considerably 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.
PROGRAM Input Stream >> (Extraction operator) Data
DEVICES OR FILES
Data
istream class
The following classes in C++ have access to file input and output functions:
ifstream ofstream fstream
Contains basic facilities that are used by all other input and output classes.It also contains a pointer to a buffer object(streambuf object). Inherits the properties of ios. Declares input functions such as get(). getline(), read(). Contains overloaded extraction operator >>.
Inherits the properties of IOS. Declares output function such as put() and write(). Contains overloaded insertion operator <<. Inherits the properties of IOS stream and ostream through multiple inheritance and thus contains all the input and output functions. Provides an interface to physical devices through buffers.It acts as a base forfilebuf class used in files.
ios istream get() getline() read() >> ostream put() write() <<
fstreambase
iostream
fstream
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);
The mode can combine two or more modes using bit wise or ( | )
Closing of File
Stream_name.close(); e.g., transaction.close();
Types of Files
. The two basic types are
text and binary.
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).
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.
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.
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
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
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)
of the file pointers yourself so that you can read from and write to an arbitrary location in the file.
seekg() function :
With one argument :
seekg(k) where k is absolute position from the beginning. The start of the file is byte 0
Begin ^ File End
k bytes
File pointer
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.
End
End
// #include <fstream.h> #include <conio.h> #include <stdio.h> void main() { //clrscr(); char c,d,ans; char str[80]; ofstream outfl("try.txt"),out("cod.dat"); ifstream infl; do { cout<<"please give the string : "; gets(str); outfl<<str; cout <<"do you want to write more...<y/n> : "; ans=getch(); } while(ans=='y'); outfl<<'\0'; outfl.close();
//clrscr(); getch(); cout <<"reading from created file \n"; infl.open("try.txt"); out.open("cod.dat"); //********************************** c=infl.get(); do { d=c+1; cout<<c<<d<<'\n'; out.put(d); c= infl.get(); } while (c!='\0'); out<<'\0'; infl.close(); outfl.close(); getch(); //********************************* }