Chapter 16

Applications with Files

16.1   INTRODUCTION

With the advancement of information technology, sea information is available on the Internet. A huge amount of data is processed in the computer networking. The information can be uploaded or downloaded from a desktop computer. The information transfer in computer networking in day-to-day life is in the form of files. The files can be written, read, or updated depending on the applications. The data are saved in the file on the disk. The file is an accumulation of data stored on the disk. The stored data can be retrieved or updated. The console I/O function reads data through input devices and displays them on the screen. The data read through these functions are temporarily stored in variables or arrays. The data stored vanishes when the program ends. In order to store the data permanently, we need to apply the disk I/O function. The disk I/O functions are associated with disk files. These functions perform read and write operations with the file. Similar to other languages, C++ also provides functions that allow the programmer to perform read and write operations with the file. The disk I/O functions in C++ are very different as compared with C, though the entire disk I/O functions of C can be used in C++. However, these functions are not appropriate for the object-oriented conditions.

Secondary storage devices such as floppy disks and hard disks are used to store data in the form of files. The main memories of a computer such as random access memory or read-only memory are not used for the storage of files. This is because the main memory of a computer is limited and cannot hold a large amount of data. Another reason is that the main memory is volatile; that is, when the computer is switched off, the contents of RAM vanish. The operating system is a set of system programs. The operating system provides programs for file management and controlling storage devices such as hard disks and floppy disks, as shown in Figure 16.1.

Fig. 16.1 Communication between program, file, and output device

As shown in Figure 16.1, the data read from the keyboard are stored in variables. Variables are created in RAM (type of primary memory). On applying the disk, I/O operations selected or all variables created in RAM can be stored to secondary storage devices such as hard disks or floppy disks. In Figure 16.1, the floppy disk is indicated. It is also possible to read data from secondary storage devices. When data are read from such devices, they are placed in the RAM and then, console I/O operations are used to transfer them to the screen. RAM is used to hold data temporarily. The variables are used to store data during program execution, and the variables are created in RAM. Hence, the secondary storage device RAM plays an important role.

The file is an accumulation of the data stored on the disk created by the user. The programmer assigns a file name. The file names are unique and are used to identify the file. No two files can have a similar name in the same directory. There are various types of files such as text files, program files, data files, and executable file. Data files contain a combination of numbers, alphabets, symbols, and so on called data.

Data communication can be performed between programs and output devices or between files and programs. File streams are used to carry the communication among the above-mentioned devices. The stream is nothing but a flow of data in bytes in sequence. If data were received from input devices in sequence, then it is called a source stream, and if the data were passed to output devices, then it is called a destination stream. Figure 16.2 shows the input and output streams. The input stream brings data to the program, and the output stream collects data from the program. In this way, the input stream extracts data from the file and transfers it to the program; whereas the output stream stores the data in the file provided by the program.

Fig. 16.2 Input and output streams

16.2  FILE STREAM CLASSES

A stream is nothing but a flow of data. In the object-oriented programming, the streams are controlled using the classes. The operations with the files mainly consist of two types. They are read and write. C++ provides various classes, as shown in Figure 16.3, to perform these operations. The ios class is the base class. All other classes are derived from the ios class. These classes contain several member functions that perform input and output operations. The streambuf class has low-level routines for controlling data buffer.

Fig. 16.3 iostream class summary

The istream and ostream classes control input and output functions, respectively. The ios is the base class of these two classes. The member functions of these classes handle formatted and unformatted operations (for more details about formatted and unformatted functions, please refer Chapter 3) input and output in C++ (section 3.6). The functions get(), getline(), and read() and overloaded extraction operators (>>) are defined in the istream class. The functions put(), write(), and overloaded insertion operators (<<)are defined in the ostream class.

The iostream class is also a derived class. It is derived from istream and ostream classes. There are three other useful derived classes. They are istream_withassign, ostream_withassign, and istream_withassign. They are derived from istream, ostream, and iostream, respectively.

The classes ifstream and ofstream are derived from istream and ostream, respectively. These classes handle input and output with the disk files. The header file fstream.h contains a declaration of ifstream, ofstream, and fstream classes, including isotream.h file. This file should be included in the program while doing disk I/O operations.

The filebuf: filebuf accomplishes input and output operations with files. The streambuf class does not organize streams for input or output operations. The derived classes of streambuf perform these operations. It also arranges a space for keeping input data and for sending output. The I/O functions of the classes istream and ostream invoke the filebuf functions to perform the insertion or extraction on the streams. It holds constant openprot used in function open() and close() as a member.

The fstreambase: The fstreambase acts as a base class for fstream, ifstream, and ofstream. The functions such as open() and close() are defined in fstreambase.

The ifstream: This class is derived from fstreambase and istream by multiple inheritance. It can access the member functions such as get(), getline(), seekg(), tellg(), and read(). It allows input operations and provides the open() function with the default input mode.

The ofstream: This class is derived from fstreambase and ostream classes. It can access the member functions such as put(), seekp(), write(), and tellp(). It allows output operations and provides the member function open() with the default output mode.

The fstream: It allows simultaneous input and output operations on a filebuf. The member function of the base classes istream and ostream starts the input and output. For example, fstream invokes the member function istream::getline() to read characters from the file. It provides the open() function with the default input mode.

16.3  STEPS OF FILE OPERATIONS

Before performing file operations, it is necessary to create a file. The operation of a file involves the following basic activities:

• File name
• Opening the file
• Reading or writing the file (file processing)
• Detecting errors
• Closing the file

The file name can be a sequence of characters, called a string. Strings are always declared with a character array. Using the file name, a file is recognized. The length of the file name depends on the operating system; for example, WINDOWS-98 supports long file names, whereas MS-DOS supports only eight characters. A file name also contains an extension of three characters. The file name should not be a device name such as LPT1 and CON. The list of device names is given in Table 16.6. You might have observed the .cpp extension to the C++ program file name separated by the dot (.). The extension is optional. The following file names are valid in MS-DOS and WINDOWS-98 operating systems:

 

The first step in the disk file I/O operation is the creation of a file stream object and connecting it with the file name. The classes ifstream, ofstream, and fstream can be used for creating a file stream defined in the header file fstream.h. The selection of the class is according to the operation that is to be carried out with the file. The operation may be read or write. Two methods are used for the opening of a file. They are as follows:

 

1. Constructor of the class

   When objects are created, a constructor is automatically executed, and objects are initialized. In the same way, the file stream object is created using a suitable class, and it is initialized with the file name. The constructor itself uses the file name as the fist argument and opens the file. The class ofstream creates output stream objects, and the class ifstream creates input stream objects.

   Consider the following examples:

    

   1. ofstream out (“text”);
   2. ifstream in (“list”);

   In the statement (a), out is an object of the class ofstream; file name text is opened, and data can be written to this file. The file name text is connected with the object out. Similarly, in the statement (b), in is an object of the class ifstream. The file list is opened for input and connected with the object in. It is also valid to use a similar name for input and output operations.

   It is possible to use these file objects in program statements such as stream objects. Consider the following statements:

    

   cout<<“One Two Three”;

    

   The above statement displays the given string on the screen.

    

   out<<“One Two Three”;

    

   The above statement writes the specified string into the file pointed by the object out as shown in Figure 16.4. The insertion operator << has been overloaded appropriately in the ostream class to write data to the appropriate stream.

   

   Fig. 16.4 Interaction between fstream object and disk file

   Consider the following statements:

    

   out<<“One Two Three”;	// Write string to the file
   out<<age;	// Write contents of variable
   out<<5000;	// Write 5000 to file
   out<<‘A’;	// Write character ‘A’ to file
   out<<123.14;	// Write 123.14 to file
   out<<123.34<<endl <<5000<<‘A’;	// Multiple values in one statement

   In the last statement, we have separated each value using an “endl” manipulator. It is essential, because when we store values such as 15 and 123.34, they are stored in the file as strings; that is, 123.34 would be stored as ‘1’,‘2’,‘3’,‘.’, ‘3’,‘4’.

   The value 123.34 requires four bytes, but when stored in a file, it occupies six bytes. When we need to store more numeric values, more bytes are occupied and the file size is increased. Every data item should be separated by a delimiter. This is essential, because during the read operation, the extraction operator cannot determine where one number is ending and another is beginning. A similar problem can be observed while reading strings. The above limitation can be overcome using the binary file operation that is discussed later in the same chapter.

   Similarly, in the following statements,

    

   in>>string;	// Reads string from the file where string is a character array
   in>>num;	// Reads number from the file where num is an integer variable

   the in object reads data from the file associated with it, as shown in Figure 16.5. For reading data from a file, we have to create an object of the ifstream class. The new line character (“ ”) inserted at the end of every line helps the overloaded operator separate the various items stored in the file. When numbers are read back from the file, they are converted into their binary format.

   

   Fig. 16.5 Interaction between ifstream object and disk file

   16.1 Write a program to open an output file using fstream class.

    

   #include<fstream.h>   //File I/O

   #include<conio.h>

    

   int main()

   {

   clrscr();

   ofstream out(“text”);

   out <<“One Two Three Four ”;

   out << “1 2 3 4”;

   out <<“ ** The End **”;

   return 0;

   }

   Explanation: In the above program, the statement ofstream out (“text”) text is opened and connected with the object out.

    

   Use of object out

   out <<“One Two Three Four ”;

   out <<“1 2 3 4”;

   out <<“ ** The End **”;

   The above statements write data (enclosed in quotation marks) to the file pointed by the object out, that is, text. The operator << is an insertion operator, and it writes the data in the file named text. To open the file text, the user can use Turbo C++ editor and click DOS Shell of the file menu. On DOS, the prompt user should type the file name and press the enter key. In addition, a further editor can be opened from the DOS prompt, and the user can see the contents of the text file. The contents of the file can be seen by the user, and it appears as follows:

    

   Contents of the file text

   One Two Three Four

   1 2 3 4

   ** The End **

   While opening a file for the writing operation, the user should give the new file name. If the given file already exists, its contents are erased and it is treated as a new file.

    

   16.2 Write a program to read data from file using object of ifstream class.

    

   #include<fstream.h>

   #include<conio.h>

    

   int main()

   {

   clrscr();

   char *n;

   ifstream in(“text”); // Opens a file in read mode

   in >>n; // Reads string from file

   cout<<n <<“”; // Displays string to the console

   in >>n ;

   cout<<n <<“”;

   in >>n ;

   cout<<n <<“”;

   return 0;

   }

    

   OUTPUT

    

   One Two Three

   Explanation: In the above program, the statement ifstream in (“text”); is opened and connected with the object in. The statement in >>n reads data from the file and assigns it to the variable followed by the (>>) extraction operator. Here, the variable *n is a character pointer. If a numeric value is read using character type, the data cannot be used for arithmetic operations. If character-type data are read using a numeric-type variable, ASCII values of the character read will be displayed. Hence, the variable type should match with the data type. The statement cout<<n <<“ ”; displays the data stored in variable n.

   In the above programs, the file associated with the object are automatically closed when the stream object goes out of scope. In order to explicitly close the file, the following statement is used:

    

   Closing of files

   out.close();

   in.close();

   Here, out is an object, and close() is a member function that closes the file connected with the object out. Similarly, the file associated with the object in is closed by the member function close().

    

   16.3 Write a program to write and read text in a file. Use ofstream and ifstream classes.

    

   #include<fstream.h>

   #include<conio.h>

    

   int main()

   {

   clrscr();

   char name[15];

   int age;

   ofstream out(“text”);

   cout<<“ Name:”;

   cin>>name;

   cout<<“Age:”;

   cin>>age;

   out<<name<<“ ”;

   out<<age <<“ ”;

   out.close(); // File is closed

   ifstream in (“text”);

   in>>name;

   in>>age;

   cout<<“ Name :”<<name<<“ ”;

   cout<<“Age:”<<age;

   in.close();

   return 0;

   }

    

   OUTPUT

    

   Name : Sameer

   Age : 24

   Name : Sameer

   Age : 24

   Explanation: The above program is a combination of the previous two programs. The out is an object of the ofstream class, and it is linked with the output file text. The data entered by the user is written in the file text. The close() function closes the file associated with the object out. Again, the same file is opened by the in object of class ifstream for reading purpose. The data recently written are read and displayed on the screen. Thus, in a program, both write and read operations are performed. The use of function close() is essential for changing the mode of the file. In case a file is not closed and an attempt is again made to open it in another mode, no compile time error is generated. However, the result will not be satisfactory.

2. The open() function

   In the last few programs, we have studied how files could be opened for reading and writing using constructors. Now, the second approach can be used with the open() function. The open() function is used to open a file, and it uses the stream object. The open() function has two arguments. First is the file name, and second is the mode. The mode specifies the purpose of opening a file; that is, read, write, append, and so on. The details are discussed in heading 16.5. In the following examples, the default mode is considered. The default values for ifstream is (ios::in) reading only and for fstream is (ios::out) writing only.

    

   (A) Opening file for write operation

   ofstream out;       // Creates stream object out

   out.open (“marks.dbf”);       // Opens file and links with the object out

   out.close()       // Closes the file pointed by the object out

   out.open (“result.dbf”);       // Opens another file

   (B) Opening file for read operation
   ifstream in;	// Creates stream object in
   in.open (“ marks.dbf”);	// Opens file and link with the object in
   in.close() ;	// Closes the file pointed by object in
   in.open (“result.dbf”);	// Opens another file

Explanation: In the above program, out is an object of the ofstream class. The object out is used with the open() function to open files for the write operation. Two files are opened: months and days. Month names are written in the file months, and number of days is written in the file days. The data are written in the files one after another. The same object is used for both the files; hence, it is necessary to close a previously linked file with the object before opening a new file. In this program, the month file is opened first and after closing it, the file days is opened. The files are closed using the function close(). The same procedure is implemented for opening the same files for the reading purpose. When the end of the file is reached, the while loop terminates.

Fig. 16.6 Stream objects with multiple files

As shown in Figure 16.6, the out object opens the month and days file one after another for writing. The object in opens these files for reading. Before opening the next file, the previously associated file with the object is closed. A single object cannot open multiple files simultaneously.

16.4   CHECKING FOR ERRORS

Until now, we have carried out the file operations without thinking whether they are performed successfully or not. If any fault occurs during a file operation, the fault cannot be detected. Various errors can be made by the user while performing a file operation. Such errors should be reported in the program to avoid further program failure. When a user attempts to read a file that does not exist or opens a read-only file for writing purpose, the operation fails in such situations. Such errors should be reported, and proper actions have to be taken before further operations are performed.

The ! (logical negation operator) overloaded operator is useful for detecting errors. It is a unary operator and, in short, it is called a not operator. The (!) not operator can be used with objects of stream classes. This operator returns a non-zero value if a stream error occurs during an operation. Consider the following program:

 

Explanation: In the above program, an existing file text is opened for reading. The file is opened successfully. Hence, no error is generated. The if() statement checks the contents in objects using the following statement: if (!in). The value of the object is 0x8f15ffd2. In case the operation fails, the value of the object in would be 0x8f160000.

 

Explanation: In the above program-using constructor of the class ifstream, a file is opened. The file that is to be opened is entered by the user during program execution. If the file does not exist, the ifstream object (in) contains 0. The if() statement checks the value of an object in, and if the operation fails, a message will be displayed and the program is terminated. In case the file exists, using the while() loop, the contents of the file are read one character at a time and displayed on the screen. You can observe the use of the NOT operator with object in if() and the while() statement. If the statement in>>resetiosflags (ios::skipws); is removed, the contents of the file would be displayed without space in one line. The operator >> ignores the white space character. Consider the following statement:

 

The NOT operator is used in association with the object. It is also possible to perform the operation without the use of the NOT operator. The following statement works opposite as compared with the above statement:

 

16.5  FINDING END OF A FILE

While reading data from a file, it is necessary to find where the file ends, that is, the end of the file. The programmer cannot predict the end of the file. If in a program, while reading the file, the program does not detect the end of the file, the program drops in an infinite loop. To avoid this, it is necessary to provide correct instructions to the program that detects the end of the file. Thus, when the end of the file is detected, the process of reading data can be easily terminated. The eof() member function() is used for this purpose. The eof() stands for the end of the file. It is an instruction given to the program by the operating system that the end of the file is reached. It checks the ios::eofbit in the ios::state. The eof() function returns the non-zero value, when the end of the file is detected; otherwise, it is zero.

 

Explanation: The above program is similar to the previous one. Here, the member function eof() is used in the if() statement. The program displays the contents of the file text. While specifying a file name for reading purpose, be sure that it exists.

 

Explanation: As explained earlier, the eof() returns one when the end of the file is found; otherwise, it is zero. Thus, until it returns zero, the program continues to read data from the file and when the end of the file is detected, the reading routine is terminated and one is displayed. In the above program, the while() loop checks the return value of the eof() function. When the eof() function is called, the following codes are executed:

 

The above function converts an ifstream object into a void pointer. It also invokes the ios::fail() function, which is as follows:

 

The above function returns the non-zero file when the end of the file is not detected. The function returns the address of the object using this pointer. Zero is returned when the end of the file is reached. The while() or if() statement checks whether the value is zero or non-zero (address of object). Here, zero means false, and non-zero means true. The details of the above functions are discussed later in the same chapter.

16.6  FILE OPENING MODES

In previous examples, we have learned how to open files using constructors and the open() function using the objects of ifstream and ofstream classes. The opening of the file also involves several modes depending on the operation to be carried out with the file. The open() function has the following two arguments:

 

Here, the object is a stream object, followed by the open() function. The bracket of the open function contains two parameters. The first parameter is the name of the file, and the second is the mode in which the file is to be opened. In the absence of a mode parameter, a default parameter is considered. The file mode parameters are as shown in Table 16.1.

 

Table 16.1 File modes

Mode parameter	Operation
ios::app	Adds data at the end of file
ios::ate	After opening character pointer goes to the end of file
ios:: binary	Binary file
ios::in	Opens file for reading operation
ios::nocreate	Opens unsuccessfully if the file does not exist
ios::noreplace	Opens files if they are already present
ios::out	Open files for writing operation
ios::trunc	Erases the file contents if the file is present

 

1. The mode ios::out and ios::trunc are the same. When ios::out is used, if the specified file is present, its contents will be deleted (truncated). The file is treated as a new file.
2. When the file is opened using ios:app and ios::ate modes, the character pointer is set to the end of the file. The ios:: app lets the user add data at the end of the file, whereas the ios:ate allows the user to add or update data anywhere in the file. If the given file does not exist, a new file is created. The mode ios::app is applicable to the output file only.
3. The ifstream creates an input stream and an ofstream output stream. Hence, it is not compulsory to give mode parameters.
4. While creating an object of the fstream class, the programmer should provide the mode parameter. The fstream class does not have the default mode.
5. The file can be opened with one or more mode parameters. When more than one parameter is necessary, a bit-wise OR operator separates them. The following statement opens a file for appending. It does not create a new file if the specified file is not present.

    

   File opening with multiple attributes

   out.open (“file1”, ios::app | ios:: nocreate)

Explanation: In the above program, the file “float.txt” is opened. If the file already exists, its contents are truncated. The three float numbers are written in the file.

 

Explanation: The above program is similar to the previous one. The only difference is that here files are opened in binary mode.

16.7  FILE POINTERS AND MANIPULATORS

All file objects hold two file pointers that are associated with the file. These two file pointers provide two integer values. These integer values indicate the exact position of the file pointers in the number of bytes in the file. The read or write operations are carried out at the location pointed by these file pointers .One of them is called get pointer (input pointer), and the second one is called put pointer (output pointer). During reading and writing operations with files, these file pointers are shifted from one location to another in the file. The (input) get pointer helps in reading the file from the given location, and the output pointer helps in writing data in the file at the specified location. When read and write operations are carried out, the respective pointer is moved.

While a file is opened for the reading or writing operation, the respective file pointer input or output is by default set at the beginning of the file. This makes it possible to perform the reading or writing operation from the beginning of the file. The programmer need not explicitly set the file pointers at the beginning of files. To explicitly set the file pointer at the specified position, the file stream classes provides the following functions:

Read mode: When a file is opened in read mode, the get pointer is set at the beginning of the file, as shown in Figure 16.7. Hence, it is possible to read the file from the first character of the file.

Fig. 16.7 Status of get pointer in read mode

Write Mode: When a file is opened in write mode, the put pointer is set at the beginning of the file, as shown in Figure 16.8. Thus, it allows the write operation from the beginning of the file. In case the specified file already exists, its contents will be deleted.

Fig. 16.8 Status of put pointer in write mode

Append Mode: This mode allows the addition of data at the end of the file. When the file is opened in append mode, the output pointer is set at the end of the file, as shown in Figure 16.9. Hence, it is possible to write data at the end of the file. In case the specified file already exists, a new file is created, and the output is set at the beginning of the file. When a pre-existing file is successfully opened in append mode, its contents remain safe and new data are appended at the end of the file.

Fig. 16.9 Status of put pointer in append mode

C++ has four functions for the setting of points during file operation. The position of the curser in the file can be changed using these functions. These functions are described in Table 16.2.

 

Table 16.2 File pointer handling functions

Function	Uses	Remark
seekg()	Shifts input ( get ) pointer to a given location.	Member of ifstream class
seekp()	Shifts output (put) pointer to a given location.	Member of ofstream class
tellg()	Provides the present position of the input pointer.	Member of ifstream class
tellp()	Provides the present position of the output pointer.	Member of ofstream class

 

As given in Table 16.2, the seekg() and tellg() are member functions of the ifstream class. All the above four functions are present in the class fstream. The class fstream is derived from ifstream and ofstream classes. Hence, this class supports both input and output modes, as shown in Figure 16.10. The seekp() and tellp() work with the put pointer, and tellg() and seekg() work with the get pointer.

Fig. 16.10 Derivation of fstream class

Now consider the following examples:

 

Explanation: In the above program the file text is opened for writing, that is, output. The text read through the keyboard is written in the file. The close() function closes the file. Once more, the same file is opened in the append mode, and data entered through the keyboard are appended at the end of the file, that is, after the previous text. The append mode allows the programmer to write data at the end of the file. The close() function closes the file. The same file is opened using the object of the ifstream class for reading purpose. The while loop is executed until the end of the file is detected. The statements within the while loop read text from the file and display it on the screen.

 

Explanation: The above program is similar to the previous one. In addition here, the function tellg() is used. This function returns the current file pointer position in the number of bytes from the beginning of the file. The number shown in brackets in the output specifies the position of the file pointer from the beginning of the file. The same program is illustrated below using the binary mode.

16.8   MANIPULATORS WITH ARGUMENTS

The seekp() and seekg() functions can be used with two arguments. Their formats with two arguments are as follows:

 

The first argument offset specifies the number of bytes the file pointer is to be shifted from the argument pre_position of the pointer. The offset should be a positive or negative number. The positive number moves the pointer in the forward direction, whereas the negative number moves the pointer in the backward direction. Fig 16.11 provides the status of pre-position arguments. The pre_position argument may have one of the following values:

 

Fig. 16.11 Status of pre-position arguments

In the above figure, the status of ios::beg and ios::end is shown. The status of ios::cur cannot be shown to be similar to ios::beg or ios::end. The ios::cur means the present position of the file pointer. The ios::beg and ios::end may be referred to as ios::cur. Suppose the file pointer is in the middle of the file and you want to read the file from the beginning, you can set the file pointer at the beginning using ios::beg. However, if you want to read the file from the current position, you can use the option ios::cur.

The seekg() function shifts the associated file’s input (get) file pointer. The seekp() function shifts the associated file’s output (put) file pointer. Table 16.3 describes a few pointer offsets along with their working.

 

Table 16.3 File pointer with its arguments

Seek option	Working
in.seekg (0,ios :: beg)	Go to the beginning of file
in.seekg (0,ios :: cur)	Rest at the current position
in.seekg (0,ios ::end)	Go to the end of file
in.seekg (n,ios :: beg)	Shift file pointer to n+1 byte in the file
in.seekg (n,ios :: cur)	Go front by n byte from the current position
in.seekg (-n,ios :: cur)	Go back by n bytes from the present position.
in.seekg (-n,ios::end);	Go back by n bytes from the end of file

In Table 16.3, in is an object of the ifstream class.

 

Explanation: In the above program, file text is opened in the output mode, and the string entered is written to the file. Again, the same file is opened for reading purpose. The statement in.seekg (0,ios::end); moves the get pointer at the end of the file. The tellg() function returns the current position of the file pointer in the file. Hence, the file pointer is set to the end of the file. The tellg() returns the number of last bytes, that is, the size of the file in bytes, and it is stored in the integer variable m. The for loop executes from 1 to m. The statement in.seekg (-i, ios::end) reads the ith byte from the end of the file. The statement in>>ch reads the character from the file indicated by the file pointer. The cout statement displays the read character on the screen. Thus, the contents of the file are displayed in reverse order.

 

Explanation: In the above program, the text is entered and written in the file text. This process is explained in the previous examples. Here again, the statement out.seekp(0,ios::beg); sets the file pointer (put pointer) at the beginning of the file. Again, text is entered and written at the current file pointer position. The previous text is overwritten.

16.9   SEQUENTIAL ACCESS FILES

C++ allows the file manipulation command to access the file sequentially or randomly. The data of the sequential file should be accessed sequentially, that is, one character at a time. In order to access the nth number of bytes, all previous characters are read and ignored. There are a number of functions to perform read and write operations with the files. Some functions read /write single characters, and some functions read/write blocks of binary data. The put() and get() functions are used to read or write a single character, whereas write() and read() are used to read or write blocks of binary data.

 

put() and get() functions

 

The function get() is a member function of the class fstream. This function reads a single character from the file pointed by the get pointer, that is, the character at the current get pointer position is caught by the get() function.

The function put() function writes a character to the specified file by the stream object. It is also a member of the fstream class. The put() function places a character in the file indicated by the put pointer.

 

Explanation: In the above program, the file data is opened simultaneously in the read and write mode. The getline() function reads the string through the keyboard and stores it in the array text [50]. The statement io.put (text[l++]) in the first while loop reads one character from the array and writes it to the file indicated by the stream object io. The first while loop terminates when the null character is found in the text.

The statement io.seekg (0) sets the file pointer at the beginning of the file. In the second while loop, the statement io.get(c) reads one character at a time from the file, and the cout() statement displays the same character on the screen. The while loop terminates when the end of the file is detected.

16.10  BINARY AND ASCII FILES

The insertion and extraction operators known as stream operators handle formatted data. The programmer needs to format data in order to represent them in a suitable manner. The description of formatted and unformatted data is given in Chapter 2. ASCII codes are used by the I/O devices to share or pass data to the computer system, but the central processing unit (CPU) manipulates the data using binary numbers, that is, 0 and 1. For this reason, it is essential to convert the data while accepting data from input devices and displaying the data on output devices. Consider the following statements:

 

Here, k is an integer variable. The operator << converts the value of the integer variable k into a stream of ASCII characters. In the same manner, the << operator converts the ASCII characters entered by the user into binary form. The data are entered through the keyboard, which is a standard input device. For example, you entered 21. The stream operator >> gets ASCII codes of the individual digits of the entered number 21, that is, 50 and 49. The ASCII codes of 2 and 1 are 50 and 49, respectively. The stream operator >> converts the ASCII value into its equivalent binary format and assigns it to the variable k. The stream operator << converts the value of k (21) that is stored in the binary format into its equivalent ASCII codes, that is, 50 and 49. Figure 16.12 shows a representation of integer numbers in ASCII and binary formats.

Fig. 16.12 Representation in binary and ASCII formats

Explanation: In the above program, the data file is opened in read mode. The file already exists. Using get() member function of the ifstream class, the contents of the file are read and displayed. Consider the following statement:

 

cout<<(char)in.get();

 

The get() function reads data from the file in the ASCII format. Hence, it is necessary to convert the ASCII number into an equivalent character. The typecasting format (char) converts the ASCII number into an equivalent character. In case the conversion is not done, the output would be as follows:

 

 

The above displayed are ASCII numbers, and –1 at the end indicates the end of the file.

After typecasting, the original string will be as shown in the output.

The write() and read() functions

The data entered by the user are represented in the ASCII format. However, the computer can understand only the machine format, that is, 0 and 1. When data are stored in the text, format numbers are stored as characters and occupy more memory space. The functions put() and get()read/ write a character. The data are stored in the file in character format. If a large amount of numeric data are stored in the file, they will occupy more space. Hence, using put() and get()creates disadvantages.

This limitation can be overcome using write() and read() functions. The write() and read()functions use the binary format of data while in operation. In the binary format, the data representation is same in both the file and the system. Figure 16.12 shows the difference between the ASCII and binary format. The bytes required to store an integer in text form depend on its size, whereas in the binary format the size is fixed. The binary form is accurate and allows quick read and write operations, because no conversion takes places during operations. The formats of the write() and read() function are as given below.

 

These functions have two parameters. The first parameter is the address of the variable P. The second is the size of the variable P in bytes. The address of the variable is converted into char type. Consider the following program:

 

Explanation: In the above program, the integer array is initialized with 7 integer numbers. The file “01.bin” is opened. The statement out.write((char *) & num, sizeof (num)) writes the integer array in the file. The &num argument provides the base address of the array, and the second argument provides the total size of the array. The close() function closes the file. Again, the same file is opened for reading purpose. Before reading the contents of the file, the array is initialized to a zero that is not necessary. The statement in.read ((char *) & num, sizeof (num)); reads data from the file and assigns them to the integer array. The second for loop displays the contents of the integer array. The size of the file “01.bin” will be 14 bytes, that is, two bytes per integer. If the above data are stored without using the write() command, the size of the file will be 21 bytes.

Reading and writing class objects

The read() and write() functions perform read and write operations in a binary format that is exactly the same as an internal representation of data in the computer. Due to the capabilities of these functions, large data can be stored in a small amount of memory. Both these functions are also used to write and read class objects to and from files. During read and write operations, only data members are written to the file, and the member functions are ignored. Consider the following program:

 

Explanation: In the above program, the class boys contains data members’ name, age, and height of char, int, and float type. The class also contains the member functions get() and show()to read and display the data. In function main(), an array of three objects is declared, that is, b [3]. The file “boys.doc” is opened in the output and input mode to write and read data. The first for loop is used to call the member function get(), and data read via the get() function is written to the file by the write() function. The same method is repeated while reading the data from the file. While reading data from the file, the read() function is used, and the member function show() displays the data on the screen.

16.11   RANDOM ACCESS OPERATION

Data files always contain a large amount of information, and the information always changes. The changed information should be updated; otherwise, the data files are not useful. Thus, to update data in the file, we need to update the data files with latest information. To update a particular record of the data file, the data may be stored anywhere in the file; it is necessary to obtain the location (in terms of byte number) at which the data object is stored.

The sizeof() operator determines the size of the object. Consider the following statements:

 

Here, o is an object, and size is an integer variable. The sizeof() operator returns the size of the object o in bytes, and it is stored in the variable size. Here, one object is equal to one record.

The position of the nth record or object can be obtained using the following statement:

 

Here, p is the exact byte number of the object that is to be updated; n is the number of the object; and size is the size in bytes of an individual object (record).

Suppose we want to update the fifth record. The size of the individual object is 26.

 

Thus, the fifth object is stored in a series of bytes from 105 to 130. Using seekg() and seekp() functions, we can set the file pointer at that position.

 

Explanation: In the above program, the class boys contains the data member’s name, age, and height. The class boys also contains the member functions input() and show(). The input() function is used to read data, and the show() function displays data on the screen.

After class definition and before the main() function array of objects, b[3] and fstream object out are declared. They are declared before main() for global access. The file boys.doc is opened in the input and output modes to perform both read and write operations.

The menu() function displays the menu on the screen. The menu items can be selected using the up arrow key. Hit enter to start the operation. There are another three user-defined functions. They are get(), put(), and update(). The get() function calls the member function input() to read data through the keyboard. The get() function writes the data using the write() function. The put() function calls the member function show(). The put() function calls the member function show(). The put() function reads the data from the file using the read() function.

The update() function is used to modify the previous record. The seekg() function sets the file pointer at the beginning of the file. The sizeof() operator determines the size of the object and stores it in the variable s.

16.12  ERROR HANDLING FUNCTIONS

Until now, we have performed the file operation without any knowledge of the failure or success of the function open() that opens the file. There are many reasons; they may result in errors during read/write operations of the program.

1. An attempt to read a file that does not exist
2. The file name specified for opening a new file may already exist
3. An attempt to read the contents of a file when the file pointer is at the end of the file
4. Insufficient disk space
5. Invalid file name specified by the programmer
6. An effort to write data to the file that is opened in the read-only mode
7. A file opened may be already opened by another program
8. An attempt to open the read-only file for writing operation
9. Device error

The stream state member from the class ios receives values from the status bit of the active file. The class ios also contains many different member functions. These functions read the status bit of the file where an error occurred during program execution are stored. These functions are depicted in Table 16.5, and various status bits are described in Table 16.4.

All streams such as ofstream, ifstream, and fstream contain the state connected with them. Faults and illegal conditions are managed (controlled) by setting and checking the state properly. Figure 16.13 describes it more clearly.

Fig. 16.13 Status bits

Table 16.4 Status Bits

eofbit	End of file encountered.	0x01
failbit	Operation unsuccessful	0x02
badbit	Illegal operation due to wrong size of buffer	0x04
hardfail	Critical error	0x08

Table 16.5 Error trapping functions

Functions	Working and return value
fail()	Returns non-zero value if an operation is unsuccessful. This is carried out by reading the bits ios::failbit, ios:: badbit, and ios::hardfail of ios::state.
eof()	Returns non-zero value when the end of the file is detected; otherwise, it returns zero. The ios::eofbit is checked.
bad()	Returns non-zero value when an error is found in the operation. The ios::badbit is checked.
good()	Returns non-zero value if no error occurred during the file operation, that is, no status bits were set. This also indicates that the above functions are false. When this function returns true, we can proceed with the file operation.
rdstate()	Returns the stream state. It returns the value of various bits of the ios::state.

The following examples illustrate the techniques of error checking:

1. An attempt to open a non-existent file for reading

    

   ifstream in(data.txt”);

   if (!in){ cout<< File not found”; }

   In the above format, an attempt is made to open a file for reading. If the file already exists, it will be opened; otherwise, the operation fails. Thus, by checking the value of the object in, we can confirm the failure or success of the operation and according to this, further processing can be decided.

2. An attempt to open a read-only file for writing

    

   ofstream out(data.txt”);

   if (!out)

   cout<<Unable to open file”;

   else

   cout<<“File opened”;

   Suppose the data.txt file is protected (marked read only) or used by another application in a multitasking operating environment. If the same file is opened in the write mode as shown above, the operation fails. By checking the value of the object out with the if() statement, we can catch the error and transfer the program control to a suitable sub-routine.

3. Checking end of file

    

   ifstream in(data.txt”);

   while (!in.eof())

   {

   // read data from file

   // display on screen

   }

   We may seek to open an existing file and read its contents. After opening a file in the read mode, it is necessary to read the characters from the file using an appropriate function (read() or get()). While reading a file, the get pointer is advanced to the successive characters, and the same process can be repeated using loops. The compiler cannot determine the end of the file. The eof() function determines the end of the file. Thus, by checking the value of the eof() function, we can determine the end of the file. In addition, by checking the value of the object, the end of the file is determined. Such conditions should be placed in the while loop parentheses. While reading the file, use only while or for loop.

4. Illegal file name

    

   ifstream in(“*+**”);

   while (!in.eof())

   {

   // read data from file

   // display on screen

   }

   While performing a file operation, it is the user’s responsibility to specify the correct file name. If an illegal file name is specified by the user, the file operation fails. In the above format, “*+**” is given as a file name that is invalid.

5. Operation with unopened file

    

   ifstream in(“DATA”);

   while (!in.eof())

   {

   // read data from file

   // display on screen

   }

   Suppose the “DATA” file does not exist and an attempt is made to open it for reading. Any operation applied with this file will be of no use. Hence, while performing a file operation, first we have to check whether the file is successfully opened or not. After the confirmation, we can proceed to the next step.

Programs referred to in the above discussion are explained below.

 

Explanation: In the above program, the object in of the ifstream class is declared globally. It can be accessed by any normal function. In the main() function, in is the object used for opening the file. If the open() function fails to open the file, it returns a zero; otherwise, it returns a non-zero value. The if statement checks the value of the object in, and if it is a non-zero show() function, it is invoked; otherwise, “File not found” message is displayed. The show() function reads the file and displays the contents on the screen. In the above program, the open() function tries to open “dat” file, which does not exist. Hence, the output is “File not found.” If the specified file exists, the contents of the file will be displayed.

 

Explanation: In the above program, an attempt is made to open a non-existent file. The if statement checks the value of the object in. The specified file does not exist; hence, it displays the message “File not found.” The program also displays the values of various bits using the functions good(), eof(), bad(), fail(), and rdstate() error trapping functions. For more information about these functions, please refer Table 16.4.

16.13  COMMAND-LINE ARGUMENTS

An executable program that performs a specific task for the operating system is called a command. The commands are issued from the command prompt of the operating system. Some arguments are associated with the commands; hence these arguments are called command-line arguments. These associated arguments are passed to programs.

Similar to C, in C++, every program starts with a main() function, and this function marks the beginning of the program. We have not provided any arguments so far in the main() function. Here, we can make arguments in the main function as in other functions. The main() function can receive two arguments, and they are (1) argc (argument counter) and (2) argv (argument vector). The first argument contains the number of arguments, and the second argument is an array of char pointers. The *argv points to the command-line arguments. The size of the array is equal to the value counted by the argc. The information contained in the command line is passed on to the program through these arguments when the main() is called up by the system.

1. Argument argc:_The argument argc counts the total number of arguments passed from command prompt. It returns a value that is equal to the total number of arguments passed through the main().
2. Argument argv:_It is a pointer to an array of character strings that contains names of arguments. Each word is an argument.

    

   Syntax - main ( int argc, char * argv[]);

   Example - ren file1 file2.

   Here, file1 and file2 are arguments, and copy is a command. The first argument is always an executable program followed by associated arguments. If you do not specify the argument, the first program name itself is an argument but the program will not run properly and will flag an error. The contents of argv[] would be as follows:

    

   argv [0] → ren

   argv [1] → file1

   argv [2] → file2

Explanation: In the above program, the main() receives two file names. The existence of the file can be checked by opening it in the read mode. If the file does not exist, the program is terminated. On the other hand, if the second file exists, the renaming operation cannot be performed. The renaming operation is carried out only when the first file exists and the second file does not exist. Make exe file of this program and use it on the command prompt.

16.14   STRSTREAMS

ostrstream

The strstream class is derived from the istrstream and ostrstream classes. The strstream class works with the memory. Using the object of the ostrstream class, different types of data values can be stored in an array.

 

Explanation: The strstream deals with the memory. If we want to pick characters from an strstream or we want to add characters into the strstream, this can be done by creating istrstream and ostrstream objects. When the object o is created, the constructor of the ostrstream is executed. Once an object of the ostrstream is created, we can assign any formatted text to the array associated with it. The statement cout<<o.rdbuf() displays the formatted information on the screen.

istrstream

It is one of the base classes of the strstream class. Using the object of the istrstream class, data can be extracted from an array. Suppose a character array contains numbers and characters. You can extract a number from an array and assign it to an integer variable. Similarly, other values can be extracted from an array. The following program illustrates this:

 

Explanation: The istrstreams is the opposite of the strstream. It picks different types of data from an array. In the above program, a character pointer text contains the data of integer, float, and character type. Using the object of the istrstreams class, we can separate the contents and store them in appropriate variables. The *book pointer variable displays a string. The remaining contents are displayed by the function rdbuf().

16.15   SENDING OUTPUT TO DEVICES

It is also possible to send information of files directly to devices such as a printer or monitor. Table 16.6 describes various devices along with their names and descriptions. The following program illustrates the use of such devices in the program:

 

Table 16.6 Standard Devices

Device Name	Description
CON	Console (monitor screen)
COM1 or AUX	Serial port – I
COM2	Serial port – II
LPT1 OR PRN	Parallel printer – I
LPT2	Parallel printer – II
LPT3	Parallel printer – III
NUL	Dummy device

Explanation: In the above program, the file name is entered through the keyboard, and it is opened for reading purpose. The ifstream object in opens the file. The ofstream object out activates the printer. The if statements check both the objects for detecting operation status, that is, whether the operations have failed or are successful. The while loop reads data from the file and using the put() statement, it passes it to the devices associated with the object out. In this program, the data read are passed to the printer. The macro eject defined at the beginning of the program advances the page of the printer. In case the printer is not attached, the message displayed will be as given below.

 

The user can select retry if he or she had attached the printer; otherwise, by selecting cancel, the operation can be cancelled.

16.16  MORE PROGRAMS

Explanation: In the above program, the user enters source and target file names. The existence of the files is checked. In case the source file is absent and the target file is already present, the copying of data will not take place. Appropriate messages are displayed when the file names are not properly entered.

The target file is opened in read and nocreate mode. The nocreate flag prevents the opening of a new file if the file is absent. If it is unsuccessful, then the open() statement within the if statement opens the file for writing. The while loop executes the function till the file pointer reaches the end of the source file. The get() statement reads data from the source file, and the put() statement writes the read data to the target file. Thus, the copying of data is carried out. After termination of the while loop, both the files are closed using close() functions.

 

Explanation: In the above program, source and target file names are entered. The content of the source file is copied to the target file in reverse order. The source file is opened for reading, and the target file is opened for writing. Using the tellg() function, the size of the source file is obtained and stored in the variable b. The for loop executes from 1 to b (size of source file). The seekg() function moves the get file pointer in the reverse order, that is, from end to top. The argument –i specifies the number of bytes to be read from the end of the file. The character read by the get() function is written to the target file by the put() function. The cout() statement displays the contents of the variable c on the screen.

 

Explanation: In the above program, the file “data.txt” is opened in the write mode. The values of the variable’s name, age, and ht are written to the file. The file is closed using the close() function.

Again, the same file is opened in the read mode. The data read are assigned to respective variables and displayed on the screen using the cout() statement.

 

Explanation: This program is similar to the previous one. Here, a string is written to the file. Using the getline() function, the string is read from the file and displayed. As soon as the end of the file is detected, the while loop terminates.

 

Explanation: In the above program, two character arrays sfile [20] and dfile [20] are declared to hold source and destination file names, respectively. The rdbuf() copies entire the source file to the target file.

 

Explanation: In the above program, character array s[] and character pointer r are initialized with strings. The strings and their memory addresses are displayed using cout() statements. The address can be displayed using the & operator in traditional C style. We can also display the address as per the statement cout<<(void*) r. The address is converted from char* into void*. The statement cout<<(unsigned)&s converts the address into an unsigned integer and displays it.

 

Explanation: In the above program, the file data.txt is in the write mode. If the file opening operation fails, the function error() is executed. The if statement checks the value of the object f, and if it is zero, then the function errors() are invoked, which display the errors. The error states displayed in the output are illustrated in Table 16.7:

 

Table 16.7 Return values of functions

rdstate() (error state = 4)	The rdstate() function gives the value 4, and it points that the file operation was unsuccessful.
fail()=4 & bad()=4	These functions display a non-zero value, and this is due to an error that is generated during the operation.
eof() = 0	This function returns zero, because the file pointer is not at the end of the file.
good() = 0	This function returns zero, because no bit sets.

 

Explanation: The above program can be executed on command prompt by creating its exe file. The number of arguments entered by the user is checked by the first if statement; if arguments are less than two, the message displayed will be “Enter numbers.”

If the user enters numbers followed by the file name, the product of all the numbers is calculated and displayed. The object value is the object of the class istrstream, and it is connected to the buffer. Consider the statement value>>n; here, the object value takes data from the buffer and assigns it to the variable n.

1. Nowadays, a huge amount of data is processed in the computer networking. The information is uploaded or downloaded from the desktop computer. The information transfer in computer networking in day-today life is done in the form of files. The data are saved in the file on the disk. The file is an accumulation of data stored on the disk.
2. A stream is nothing but the flow of data. In the object-oriented programming, the streams are controlled using the classes.
3. The istream and ostream classes control the input and output functions, respectively.
4. The iostream class is also a derived class. It is derived from the istream and ostream classes. There are another three useful derived classes. They are istream_withassign, ostream_withassign, and iostream_withassign, and they are derived from istream, ostream, and iostream, respectively.
5. filebuf accomplishes input and output operations with the files. The fstreambase acts as a base class for fstream, ifstream, and ofstream. The ifstream class is derived from the fstreambase and istream classes by multiple inheritance. It can access the member functions such as get(), getline(), seekg(), tellg(), and read(). The ofstream class is derived from the fstreambase and ostream classes. It can access the member functions such as put(), seekp(), write(), and tellp(). The fstream class allows for simultaneous input and output on a filebuf. The member function of the istream and ostream in the base classes starts the input and output, respectively.
6. The following two methods are used for the opening of a file: (A) Constructor of the class; (b) Member function open() of the class.
7. The class ofstream creates output stream objects, and the class ifstream creates input stream objects.
8. The close() member function closes the file.
9. The open() function uses the same stream object. The open() function has two arguments. The first is the file name, and the second is the mode.
10. When the end of the file is detected, the process of reading data can be easily terminated. The eof() function() is used for this purpose. The eof() stands for the end of the file. It is an instruction given to the program by the operating system that the end of the file is reached. The eof() function returns one when the end of the file is detected.
11. The mode ios::out and ios::trunc are near about same. The ios:: app lets the user add data at the end of the file, whereas ios: ate allows the user to add or update data anywhere in the file.
12. The seekg() function shifts the associated file’s input (get) file pointer. The seekp() function shifts the associated file’s output (put) file pointer.
13. seekg() -- Shifts input ( get ) pointer to a given location
14. seekp() -- Shifts output (put) pointer to a given location
15. tellg() -- Provides the present position of the input pointer
16. tellp() -- Provides the present position of the output pointer
17. The put() and get() functions are used to read or write a single character, whereas the write() and read() functions are used to read or write blocks of binary data.
18. The fail(), eof(), bad(), and good() are error trapping functions.
19. An executable program that performs a specific task for the operating system is called a command. The commands are issued from the command prompt of the operating system. Some arguments are to be associated with the commands; hence, these arguments are called command-line arguments.
20. Syntax - main ( int argc, char * argv[]);

(A) Answer the following questions

1. What is a stream?
2. What is a file?
3. Describe the different classes derived from ios that control the disk I/O operations.
4. Describe the two methods of opening a file.
5. Explain the detection of the end of a file with the function eof().
6. Describe the syntax of the open() function with its arguments.
7. What are the different types of file opening modes? List their names along with their meanings.
8. Describe file manipulators with their syntaxes.
9. Describe the various error trapping functions.
10. What are the possible reasons for the failure of the open() function?
11. What are command-line arguments?
12. Explain the use of the NOT operator and eof() function.
13. Explain sequential and random file operations.
14. How would you write data in a file in binary format?
15. What are the limitations of using the put() and get() functions?
16. Explain the uses of the ostrstream and istrstream classes.
17. Explain the differences between binary and ASCII files.

(B) Answer the following by selecting the appropriate option

1. The eof() stands for
   1. end of the file
   2. error opening the file
   3. error of the file
   4. none of the above
2. Command-line arguments are used with function
   1. main()
   2. member function
   3. with all functions
   4. none of the above
3. The statement in.seekg(0,ios::end) sets the file pointer
   1. at the end of the file
   2. at the beginning of the file
   3. in the middle of the file
   4. none of the above
4. The close() function
   1. closes the file
   2. closes all opened files
   3. closes only read mode file
   4. none of the above
5. The write() function writes
   1. single character
   2. an object
   3. a string
   4. none of the above
6. What will be the value of the variable c after execution of the following program?

   #include<fstream.h>

   void main()

   {

   char text[5];

   ofstream out (“data.txt”);

   out<<“Programming with ANSI and Turboc C”;

   out.close();

   ifstream in (“data.txt”);

   int c=0;

   while (!in.eof())

   { in.getline(text,5);

   c++; }

   }

   1. c = 9
   2. c = 2
   3. c = 5
   4. c = 1
7. What will be the values of the variables j and k after execution of the following program?

   #include<fstream.h>

   void main()

   {

   ofstream j;

   ifstream k;

   cout<<“j=”<<sizeof(j) <<endl;

   cout<<“k=”<<sizeof(k);

   }

   1. j = 78 k = 80
   2. j = 80 k = 80
   3. j = 80 k = 78
   4. none of the above
8. The object of the fstream class provides
   1. both read and write operations
   2. only read operation
   3. only write operation
   4. none of the above
9. To add data at the end of the file, the file should be opened in
   1. append mode
   2. read mode
   3. write mode
   4. both (a) and (c)
10. When a file is opened in read or write mode, the file pointer is set
    1. at the beginning of the file
    2. at the end of the file
    3. in the middle of the file
    4. none of the above
11. While performing a file operation, the following file should be included:
    1. fstream.h
    2. iostream.h
    3. constream.h
    4. all of the above
12. The constructor of the following class requires a file name and mode for opening a file:
    1. ifstream
    2. ofstream
    3. fstream
    4. all of the above

(C) Attempt the following programs

1. Write a program to open a file in the output and input mode. Accept data and write to the file. Display the contents of the file.
2. Write a program to write and read data in a file using object I/O functions write() and read(). Declare a class with the data member’s name [20], int billno, int amount_debited, and int received _amount and int balance. Add 10 records and display the list of people with their balances. The use should have a facility to modify the existing records.
3. Write a program to read and write a data file. While writing data, pay attention to the following instructions:
   1. Add one space between two successive words.
   2. Capitalize the first character of sentences.
   3. If numerical data are present, enclose them within brackets.
4. Write a program to copy the contents of one file to another file. Use command-line arguments.
5. Write a program to read a file. Display the total number of characters, words, lines, and blank spaces in the file.
6. Write a program to exchange the contents of two files. Use command-line arguments.
7. Write a program to compare two files in terms of the number of bytes.
8. Write a program to count the characters and numericals present in a file.
9. Write a program to print the contents of a file on a printer.
10. Write a program to check whether the given file exists or not. Display a suitable message. The user should enter the file name.
11. Write a program to write the contents of one file in reverse order into another file.
12. Write a program to find the length of a file.

(D) Find the bugs in the following programs

1.  

   ifstream in;

   void main()

   {

   ifstream in;

   void show (void);

   in.open(“data”) ;

   if (in!=0) show();

   else cout<<“ File not fount”;

   }

   void show()

   { char c;

   cout<<“ Contents of file:”;

   while (in) {in.get(c);
   cout<<c;}

   }

   Tip: Assume the file “data” exists.

2.  

   void main()

   {

   char name[15];

   ofstream out(“text”);

   cin >>name;

   out<<name<<“ ”;

   ifstream in(“text”);

   in>>name;

   cout<<“ Name

   t:”<<name<<“ ”;

   in.close();

   }

3.  

   void main()

   {

   ifstream in(“data”);

   while (in) { cout<<(char)

   in.get(); }

   return 0;

   }

   Tip: Assume the file “data” exists.

4.  

   void main()

   {

   fstream in(“data”);

   while (in.eof()==0)

   {

   cout<<(char)in.get();

   }

   }