HOME WORK-3

Submitted by:- Submitted to:-

Name –Shivangi shukla Miss. Tajinder Kaur
BCA 1st year
Roll-no:- A17

Q1. Differentiate class to basic and basic to

class type conversions with example.
Ans:-
Conversion from a basic type to a class type may be
achieved using SUITABLE CONSTRUCTORS IN CLASS.

EX:
class distance
{
int feet;
float inch;

public:

distance(float p) //costructor to concert basic type to

class type
{

feet= (int) p;
inch=(p-feet)*12;
}

void show()
{
cout<<"feet="<<feet;
cout<<"inch="<<inch;
}
};

//Conversion CLASS TO BASIC//String object to basic string

#include <iostream.h>

#include <string.h>
#include <conio.h>

classstring
{
char *p;
int len;
public:
string()
{}
string(char *a)
{
len=strlen(a);
p=newchar[len+1];
strcpy(p,a);
}
operatorchar*()
{
return(p);
}
void display()
{
cout<<p;
}
};

void main()
{
clrscr();
string o1="vivek";
cout<<"String of Class type : ";
o1.display();
cout<<endl;

char *str=o1;

cout<<"String of Basic type : "<<str;

getch();
}
Q2. Explain the various methods to open a file. Also
write a program to create a file and then display
its contents on the screen with the help of open()
function.
Ans:---There are some classes provided to us for
performing many other operations other than
opening:-----------------------------------------------------------

Classes for the file stream operations :

The I/O system of C++ contains a set of classes that define the
file handling methods.

These include ifstream, ofstream and fstream.

These classes, designed to manage the disk files, are declared in

fstream.h and therefore we must include this file in any program
that uses files.
Details of some useful classes :
filebuf
Its purpose is to set the file buffer to read and write. Contains
openprot constant used in the open() of the filestream classes.
Also contains close() and open() as member functions.

fstreambase
Provides operations common to the file streams. Serves as a base
for fstream, ifstream and ofstream classes. Contains open() and
close() functions.

ifstream
Provides input operations. Contains open() with default input
mode. Inherits the functions get(), getline(), read(), seekg() and
tellg() functions from istream.

ofstream
Provides output operations. Contains open() with default output
mode. Inherits put(), seekp(), tellp(), and write() functions from
ostream.
fstream
Provides support for simultaneous input and output operations.
Contains open() with default input mode. Inherits all the functions
from istream and ostream classes through iostream.

The ifstream, ofstream and fstream classes are declared

in the file fstream.h
The istream and ostream classes are also included in the
fstream.h file.

there are various methods for opening a file:--------------------------

Opening and closing a file :

For opening a file, we must first create a file stream and than link
it to the filename.

A filestream can be defined using the classes ifstream, ofstream,

and fstream that are contained in the header file fstream.h

A file can be opened in two ways:

Using the constructor function of the class. This method is
useful when we open only one file in the stream.

Using the member function open() of the class. This

method is used when we want to manage multiple files
using one stream.

Using Constructor
Create a file stream object to manage the stream using the
appropriate class. That is, the class ofstream is used to create the
output stream and the class ifstream to create the input stream.

Initialize the file object with the desired filename, e.g.:

ofstream outfile(“sample.txt”);
The above statement creates an object outfile of class ofstream
that manages the output stream. This statement also opens the
file sample.txt and attaches it to the output stream for writing.

Similarly, the statement declared in as an ifstream object and

attaches to the file “sample.txt” for reading.

ifstream infile(“sample.txt”);

Program: Writing and reading data into file, using constructors

# include
void main()
{
ofstream outfile(“sample.txt”); // create file for output
char ch = ‘a’;
int i = 12;
float f = 4356.15;
char arr[ ] = “hello”;
outfile << ch << endl <<< endl << f << endl << arr; //send the
data to file
outfile.close();

ifstream infile(“sample.txt”);

infile >> ch >> i >> f >> arr; // read data from file

cout << ch << i << f << arr; // send data to screen

}

To write data into the file, character by character.

#include
#include
void main()
{
char str[]=“C++ is superset of C. It is an object-oriented /
programming language.”;

ofstream outfile(“sample2.txt”); // Open the file in write mode

for(int i = 0; i < strlen(str); i++)

outfile.put(str[i]); // write data into the file, character by
character.
}

Writing and reading Objects of a class :

So far we have done I/O of basic data types. Since the class
objects are the central elements of C++ programming, it is quite
natural that the language supports features for writing and
reading from the disk files objects directly.

The binary input and output functions read() and write() are
designed to do exactly this job.

The write() function is used to write the object of a class into the
specified file and read() function is used to read the object of the
class from the file.

Both these functions take two arguments:

1. address of object to be written.
2. size of the object.

The address of the object must be cast to the type pointer to

char.

One important point to remember is that only data members are

written to the disk file and the member functions are not.
Writing an object into the file

#include
class Person
{
private:
char name[40];
int age;
public:
void getData()
{
cout << “\n Enter name:”; cin >> name;
cout << “\n Enter age:”; cin >> age;
}
} ; // End of the class definition

void main()
{
Person per ; // Define an object of Person class

per.getData(); // Enter the values to the data members of the

class.

ofstream outfile(“Person.txt”); // Open the file in output mode

outfile.write((char*)&per, sizeof(per)); // Write the object into the

file
}

fstream object can be used for both input & output.

In the open() function we include several mode bits to specify

certain aspects of the file object.
app -> To preserve whatever was in the file before. Whatever we
write to the file will be appended to the existing contents.

We use in and out because we want to perform both input and

output on the file.

eof() is a member function of ios class. It returns a nonzero value

if EOF is encountered and a zero otherwise.

Parameters of open() function

Parameter Meaning
ios::app Append to end of the file
ios::ate Go to end of the file on opening
ios::in Open file for reading only
ios::nocreate Open fails if the file does not exist
ios::noreplace Open fails if the file already exists
ios::out Open file for writing only
ios::trunc Delete contents of the file if it exists

opening a file using the open

function:--------------------------------
EX:- #include <iostream.h>
#include <string.h>
#include <fstream.h>
using namespace std;

int main()
{

fstream File;
string array[10];

File.open("Data.txt", ios::out);

if (File.is_open ()) {
for (int x = 0; x <= 9; x++)
{
cout<< x <<" Enter a string:"<<endl;
cin>> array[x];
File<< array[x] << ", ";
cout<<endl;
}
}
File.close();

return 0;
}

Q3. Describe the concept of file mode while opening

a file.

Ans:- ios::app If FileName is a new file, data is written to it.

If FileName already exists and contains data, then it is opened,
the compiler
goes to the end of the file and adds the new data to it.

ios::ate If FileName is a new file, data is written to it and

subsequently

added to the end of the file.

If FileName already exists and contains data, then it is opened
and data is
written in the current position.

ios::in If FileName is a new file, then it gets created fine as an

empty file.

If FileName already exists, then it is opened and its content is

made
available for processing

ios::out If FileName is a new file, then it gets created fine as an

empty file.

Once/Since it gets created empty, you can write data to it.

If FileName already exists, then it is opened, its content is
destroyed, and
the file becomes as new. Therefore you can create new data to
write to it.
Then, if you save the file, which is the main purpose of this mode,
the new
content is saved it.*This operation is typically used when you
want to save
a file

ios::trunc If FileName already exists, its content is destroyed and

the file

becomes as new

ios::nocreate If FileName is a new file, the operation fails because

it

cannot create a new file.

If FileName already exists, then it is opened and its content is
made
available for processing

ios::noreplace If FileName is a new file, then it gets created fine.

If FileName already exists and you try to open it, this operation
would fail
because it cannot create a file of the same name in the same
location.
Q4. Jot down the various functions for manipulation of file
pointers.

Ans:- Functions for manipulation of file pointers

seekg
Sets the position of the get pointer. The get pointer determines
the next location to be
read in the source associated to the stream.
Syntax:

seekg ( position );

Using this function the stream pointer is changed to the absolute

position (counting
from the beginning of the file). seekg ( offset, direction );

Using this function, the position of the get pointer is set to an

offset value relative to
some specific point determined by the parameter direction. offset
is of the member
type off_type, which is also an integer type. And direction is of
type seekdir, which is an
enumerated type (enum) that determines the point from where
offset is counted from.
seekp
The seekp method changes the location of a stream object's file
pointer for output (put
or write.) In most cases, seekp also changes the location of a
stream object's file pointer
for input (get or read.)
seekp ( position );
Using this function the stream pointer is changed to the absolute
position (counting
from the beginning of the file).

seekp ( offset, direction );

Using this function, the position of the put pointer is set to an
offset value relative to
some specific point determined by the parameter direction. offset
is of the member
type off_type, which is also an integer type. And direction is of
type seekdir, which is an
enumerated type (enum) that determines the point from where
offset is counted from
tellg
The tellg() function is used with input streams, and returns the
current "get" position of
the pointer in the stream.
Syntax:
pos_type tellg();
It has no parameters and return a value of the member type
pos_type, which is an
integer data type representing the current position of the get
stream pointer.

tellp
Returns the absolute position of the put pointer. The put pointer
determines the
location in the output sequence where the next output operation
is going to take place.
Syntax:
pos_type tellp();
The tellp() function is used with output streams, and returns the
current "put" position
of the pointer in the stream. It has no parameters and return a
value of the member
type pos_type, which is an integer data type representing the
current position of the put
stream pointer.

Specifying the offset :

The seek functions seekg() and seekp() can also be used with two
arguments
as follows:
seekg(offset, refposition);
seekp(offset, refposition);
The parameter offset represents the number of bytes the file
pointer to be
moved from the location specified by the parameter refposition.
The refposition takes one of the following these constant defined
in the ios
class.
ios::beg start of the file
ios::cur current position of the pointer
ios::end end of the file.

EX:
class person
{
private:
char name[40];
int age;
public:
void showData()
{
cout << “\n Name = “ << name;
cout << “\n Age = “ << age; } };

void main()
{
person pers; // create person object
ifstream infile; // create input file
infile.open(“Person.txt”); // open the file
infile.seekg(0, ios::end); // go to end from 0 byte
int endposition = infile.tellg(); // find where we are
int n = endposition/sizeof(person); // number of persons
cout << “\n There are “ << n << “ persons in file: “;
cout << “\n Enter person number: “;
cin >> n;
int position = (n-1) * sizeof(person); // number times size

infile.seekg(position);
infile.read( (char*)&pers, sizeof(pers) );
pers.showData(); // display the person

}
Q5. Write down a program in C++ implementing file handling that
uses various error handling functions.
Ans:-

ios::good function)

ios::fail Check if either failbit or badbit is set (public member

function )
ios::bad Check if badbit is set (public member function)

ios::rdstate Get error state flags (public member function)

ios::clear Set error state flags (public member function)

Check if the state of the stream is good for i/o operations. (public
member

#include <fstream.h>
#include <string.h>
#include <iostream.h>
using namespace std;
void check_stream_state1(const fstream &s)
{
int state = s.rdstate();

if (!state)
{
cout << "goodbit - no error occurred" << endl;
}
else
{
if (state & ios::badbit)
cout << "badbit - a fatal I/O error has occurred" << endl;
if (state & ios::eofbit)
cout << "eofbit - end of file is encountered" << endl;
if (state & ios::failbit)

cout << "failbit - a nonfatal I/O error has occurred" << endl;
}}
void check_stream_state2(const fstream &s)
{
//true if no error indicators are set

if(s.good())
{
cout << "good() returned true" << endl;
}
else
{

if (s.bad())
cout << "bad() returned true" << endl;

if (s.eof())
cout << "eof() returned true" << endl;
if(s.fail())
cout << "fail() returned true" << endl;
}}
int main()
{
fstream output("stream.txt", ios::out);
//using member function good()
if(output.good())
{
//write text to the file
output << "Text To File" << endl;
}
//check that goodbit is set
check_stream_state1(output);
check_stream_state2(output);

output.close();

output << "Some More Text" << endl;

check_stream_state1(output);
check_stream_state2(output);
fstream input("stream.txt", ios::in);
string text;
//using member function eof()
while(!input.eof())
{
getline (input, text);
cout << text << endl;
}

input.clear();

input << "Some More Text" << endl;

check_stream_state1(input);
check_stream_state2(input);

input.clear();

input.seekg(0,ios::beg);
int number = 0;

input >> number;

check_stream_state1(input);
check_stream_state2(input);

output.close();
return 0; }