SOLUTION

It makes sense, as the constructor for the derived class is build upon the data members of the base class.

SOLUTION

Deriving publicly is a way of saying, “ is a type of “.

SOLUTION

It simply reflects an implementation shortcut.

SOLUTION

In privately derived class, data can be accessed only through member functions of the derived class.

SOLUTION

Visibility mode specifies whether the features of the base class are privately derived, or publicly derived or protected derived.

SOLUTION

The derived class cannot access the private members of its super class.

SOLUTION

Multilevel inheritance is, when a subclass inherits a base class that itself inherited from another base class.

SOLUTION

Hybrid inheritance is the combination of different form of inheritance.

SOLUTION

In hierarchical inheritance many subclasses inherited from a single base class.

SOLUTION

Derived classes (sub-classes) inherit the properties of a base class (super class).

SOLUTION

Reusability is the feature using which we can use the already tested code again and again. It saves development time and easy to maintain.

SOLUTION

In C++, Polymorphic functions can be implemented using overloading functions and virtual functions.

SOLUTION

A derived class inherits all the features of a base class, and can add new features to it. But, by adding new features to the derived class, base class remains the same.

SOLUTION

The ifstream function provides an interface to read data from files as input streams.

SOLUTION

The function get( ) extracts a character from the stream and returns its value and the function getline( ) extracts more than one character from the stream.

SOLUTION

The function rdstate() returns the current internal error state flags of the stream. The internal error state flags are automatically set by calls to input/output functions to signal certain types of error that happened during their execution.

SOLUTION

The get( ) function extracts a character from the stream and returns its value . The put( ) function writes one character to the output stream.

SOLUTION

Once the file gets opened in ios :: app mode, the previous records are retained and new data gets appended to the file.

SOLUTION

ios :: noreplace causes the open( ) function to fail if the file already exists. This is used when one wants to create a new file at the same time.

SOLUTION

fstreambase provides operations common to fstream, ifstream and ofstream file streams. It also contains open() and close() functions.

SOLUTION

int ios::precision(int n) sets the floating-point precision to 'n'. and returns the previous precision.

SOLUTION

When the skipws format flag is set, as many whitespace characters as necessary are read and discarded from the stream until a non-whitespace character is found before every extraction operation. Tab spaces, carriage returns and blank spaces are all considered whitespaces.

SOLUTION

With ios::app, every output is appended at the end of the file.

SOLUTION

Typically, the data is stored in a buffer as it is retrieved from an input device (such as a keyboard) or just before it is sent to an output device (such as a printer).

SOLUTION

The file ios:ate helps to go to the end of the file when opened.

SOLUTION

A sequential file is designed for efficient processing of records in a sorted order on some search key.

SOLUTION

In ios::trunc, if the file does not exist, a new empty file is created. If the file exists, its content is deleted and it is treated as a new file.

SOLUTION

A serial file is one in which the records are stored in the order in which they occur. They are not sorted into any particular order.

SOLUTION

seekg( ) sets the position of the get pointer at the beginning of the file. 20 indicates the position of the byte in a file.

SOLUTION

seekg( ) sets the position of the get pointer at the beginning of the file.

SOLUTION

ofstream provides an interface to write data to files as output streams.

SOLUTION

The function returns true if none of the stream's error flags are set. This function is not exactly opposite of bad( ), which only checks whether the bad bit error flag is set.

SOLUTION

The fail() function returns true if an error has occurred with the current stream, otherwise false . This can be used for checking whether the previous operation has failed.

SOLUTION

Even though, we cannot create an object of an abstract class, but we can create a pointer to an abstract class.

SOLUTION

The binding which is done at the compile time is called static binding or early binding.

SOLUTION

A class can be derived publicly, privately or protectedly. All three types of inheritance are possible.

SOLUTION

We just want the base class declaration, to derive a class from a base class. The declaration is generally present in the header files.

SOLUTION

A derived class constructor can invoke base class constructor by passing appropriate arguments that it received for a base class constructor.

SOLUTION

When we derive a class, we may or may not add new members to it. But to construct new members, new constructor (s) must be written for the derived class.

SOLUTION

It is valid when a derived class inherits an indirect base class more than once.

SOLUTION

With privatly derived class, the protected members of the base class become private members of the derived class.

SOLUTION

Polymorphic functions can be implemented using overloading functions and virtual functions.

SOLUTION

When a subclass inherited from a class which, itself inherited from another class, this is known as multilevel inheritance.

SOLUTION

We can declare common ancestor as virtual, or use ::,i.e.,scope resolution operator.

SOLUTION

Constructor is a special member function, that allows us to set up values while defining the object, without the need to make a separate call to a member function.

SOLUTION

Private members of a base class are not directly accessible in the base class but this does not affects their visibility.

SOLUTION

A similar relation between two classes is known as HOLDS-A relation. It is similar to HAS-A relationship but ownership is missing in HOLDS-A relation.

SOLUTION

Private inheritance should be used when the derived classes cannot be viewed as a type of their base class.

SOLUTION

Protected inheritance should be used, when the situation requires the attributes of base class to be available only to the derived class members but not to the outside world.

SOLUTION

A class may contain objects of another class. This situation is called nesting of objects and in such situation, the contained objects are constructed first before constructing the objects of the enclosing class.

SOLUTION

With publicly derived class, public members becomes the public members of derived class and protected becomes protected members of derived class.

SOLUTION

In public derivation, the inherited members need not be re-defined in the derived class.

SOLUTION

There are three visibility modes: private, protected, and public.

SOLUTION

Field is the smallest unit of a file. Field is characterized by its size, length and type.

SOLUTION

We cannot use two get() simultaneously in cin. get() function returns a reference to istream. It cannot return the reference twice.

SOLUTION

ofstream is used for output to a file. For an ofstream object, the file open mode can be either ios::out to output data to a file or ios::app to append data to the end of file.

SOLUTION

seekg() function sets the position of the get pointer. The get pointer determines the next location to be read in the source associated to the stream.

SOLUTION

seekg( ) function sets the position of the get pointer. The get pointer determines the next location to be read in the source associated to the stream.

SOLUTION

A stream is a general name given to a flow of data. Different streams are used to represent different kinds of data flow.

SOLUTION

A key field is a field or set of fields of a database (typically a relational database) table, which together form a unique identifier for a database record (a table entry).

SOLUTION

When two sorted files are merged into a third file, three stream objects are required.

SOLUTION

open() is ofstream member function which opens the file and attaches the file to the ofstream object.

SOLUTION

A file can be opened in C++ by two methods: (a) By using the constructor of the stream class (b) By using the open() function of the stream class

SOLUTION

ios::ate seeks to end-of-file upon opening of the file. I/O operations can still occur anywhere within the file.

SOLUTION

A file can be opened in C++ in two ways: (a)By using the constructor of the stream class (b)By using the open() function of the stream class

SOLUTION

The above statement is invalid as integer array cannot be read using getline() function.
The prototype of getline() function is - istream & getline(char * buf, int num, char delim ='n'); The getline() function reads characters from input stream and puts them in the array pointed to by buf until either num characters have been read, or the character specified by delim is encountered.

SOLUTION

We cannot use two get() simultaneously in cin. The get() returns a reference to istream. It cannot return the reference twice.

SOLUTION

The prototype of write function is - ostream& write ( const char* s , streamsize n ); It writes the block of data pointed by s, with a size of n characters, into the output buffer. The characters are written sequentially until n have been written.

This is an unformatted output function and what is written is not necessarily a c-string, therefore any null-character found in the array s is copied to the destination and does not end the writing process. 

SOLUTION

The prototype of read function is - istream& read ( char* s, streamsize n ); It reads a block of data of n characters and stores it in the array pointed by s.

SOLUTION

The functions read() and write() are used for reading and writing class objects. These functions handle the entire structure of an object as a single unit, using the computer's internal representation of data.

SOLUTION

fstreambase class provides a set of common functions.

SOLUTION

Two for reading and the third for writing.

SOLUTION

The ios::ate file mode seeks to end-of-file upon opening of the file. I/O operations can still occur anywhere within the file.

SOLUTION

The data files are the files that store data pertaining to a specific application for later use. The data files can be stored in two ways: text files and binary files. When we work with files in C++, unless we specify, files are by default considered and treated as text files.

SOLUTION

The function eof() is used to detect when the end of file is reached. The prototype is : int eof(); It returns nonzero when the end of file has been reached, otherwise it returns zero.

SOLUTION

The get ()does not extract the delimiter character from the input stream.

SOLUTION

The function read() is used to read blocks of binary data.This function handles the entire structure of an object as a single unit, using the computer's internal representation of data.

SOLUTION

The ios::app file mode causes all output to that file to be appended to the end. This value can be used only with files capable of output.

SOLUTION

ios::nocreate constant causes the open() function to fail if the file does not already exist. It will not create a new file with that name.

SOLUTION

A text file stores information in ASCII characters. In text files, each line of text is terminated(delimited) with a special character known as EOL(End Of Line) character. In text files, some internal translations take place when this EOL character is read or written.

SOLUTION

If the data(after some processing) is to be sent from memory to file, then the link can be said to be Memory-to-File link. So it is used for output purposes. 

SOLUTION

The ifstream open() method and constructor use ios :: in (open for reading) as the default value for the mode argument, while the ofstream open() method and constructor use ios :: out (open for writing) as the default.

SOLUTION

The classes defined inside fstream.h derive from classes under iostream.h.

SOLUTION

The file I/O system of C++ contains a set of classes that define the file handling methods. These classes, designed to manage the disk files, are declared in fstream.h. Therefore, we must include this file in a program that works with files.

SOLUTION

A file is closed by disconnecting it with the stream it is associated with. The close() function accomplishes this task and takes the following general form:

stream_object.close();

SOLUTION

The classes I/O system of C++ contains a set of classes that define the file handling methods. These classes, designed to manage the disk files, are declared in fstream.h.  Therefore, we must include this file in a program that works with files. To create an input stream, you must declare the stream to be of class ifstream. To create an output stream, you must declare it as class ofstream. Streams that will perform both input and output operations must be declared as class fstream.

SOLUTION

A file is closed by disconnecting it with the stream it is associated with. The close() function accomplishes this task and it takes the following general form :     stream_object.close(); close() function flushes the buffer before terminating the connection of the file with the stream.

SOLUTION

The stream that supplies data to the program is known as input stream. It reads the data from the file and hands it over to the program. The stream that receives data from the program is known as output stream.

SOLUTION

The stream that supplies data to the program is known as input stream. It reads the data from the file and hands it over to the program.

SOLUTION

Two objects are needed for reading the two files and third object is needed to write to the third file.

SOLUTION

This function seeks to end-of-file upon opening of the file.

SOLUTION

This function handles the entire structure of an object as a single unit, using the computer's internal representation of data.

SOLUTION

All C++ compilers come with classes for streaming input from the console and output to the console. These classes are defined by putting the directive #include at the top of the code. The istream class has methods for detecting input errors and the end of input data. The ostream class has methods for formatting output, i.e. specifying scientific notation, fixed decimal notation, or a combination thereof and for specifying the number of decimal digits displayed. Using some of the features of these classes, we add the capability of reading and writing our own custom types. Finally, the ifstream and ofstream classes let us read from and write to named files.

SOLUTION

Function get() reads one character at a time but read() can read chunks like structures and objects at a time.

SOLUTION

Some member functions of fstream class are seekp(), seekg(), tellg() and tellp().  Functions seekg() and tellg() are used with the input stream.  Common forms of these functions are –

            a)   ifstream & seekg(long);

            b)   ifstream & seekg(long, pos)  ;

            c)   long tellg();

In form a) seekg() positions the get pointer at an absolute position given by the long integer.

In form b) seekg() positions the get pointer at a position given by the long integer and by the value of pos.

Position can be -        ios :: beg                // from beginning of file

                                          ios :: cur                // from current position

                                          ios :: end               // from the end

In form c) tellg() gives the byte position of the get pointer in the file as a long integer. 

SOLUTION

ios::ate - This seeks to end-of-file upon opening of the file. I/O operations can still occur anywhere within the file.
ios::app - This causes all output to that file to be appended to the end. This value can be used only with files capable of output.

SOLUTION

Both get() and getline() can read characters from the input stream into a character array till the specified number of characters are entered or till the delimiting character is encountered( ‘n’ by default). The major difference is that get() does not extract delimiter newline character from the input stream. On the other hand, getline() does extract the delimiter newline character from input stream so that stream type is empty after getline() is over.

SOLUTION

Text files are also called ASCII files.  They store information in the form of ASCII characters. There are 128 different ASCII codes.  Also, text files contain lines of text and each of these has an end-of-line (EOL) marker automatically appended whenever you indicate that you have reached the end of a line. When a file is opened in text mode, various character translations take place. In case of binary files, information is stored in the same format in which it is stored in the memory.  No character translation takes place when a binary file is opened,  because of which binary files can be read and written faster by the computer.

SOLUTION

#include < fstream.h>

class Employee{

int empcode;

char empname[20];

char depart[20];

public:

void getdat(){

cout<<"nEmployee Code : ";

cin>>empcode;

char c=cin.get();

cout<<"nEmployee Name : ";

cin.getline(empname,20);

cout<<"nDepartment : ";

cin.getline(depart,20);

}

void dispdat(){

cout<<"nEmployee Code : "<< empcode;

cout<<"nEmployee Name : "<< empname;

cout<<"nDepartment : "<< depart;

}

};

void main(){

Employee e;

int num=0;

char fname[13];

cout<<"Enter file name ";

cin>>fname;

ifstream ifl;

ifl.open(fname, ios::in|ios::binary);

if(!ifl){

cout<<"Cannot open file "<< fname;

return;

}

while(ifl) {

ifl.read((char*)&e,sizeof(Employee));

e.dispdat();

}

ifl.close();

}

SOLUTION

#include < fstream.h >

#include < string.h >

class Book
{

int bookcode;

char bookname[20];

public:

void getdat()
{

cout<<"nBook Code : ";

cin>>bookcode;

char c=cin.get();

cout<<"nBook Name : ";

cin.getline(bookname,20);

}

void dispdat()
{

cout<<"nBook Code : "<< bookcode;

cout<<"nBook Name : "<< bookname;

}

int match(int cd)
{

if(cd==bookcode)

return 1;

else

return 0;

}

};

void main()
{

Book b;

ifstream ifl;

ifl.open("Books.dat",ios::in|ios::binary);

if(!ifl)
{

cout<<"Unable to open file - Returning";

return;}

while(ifl)
{

ifl.read((char *)&b,sizeof(Book));

b.dispdat();

}

}