EEB 334 - Chapter 6

Dr. Sajid M.
Sheikh
Senior Lecturer
Department of Electrical Engineering
University of Botswana
Office No: 248/106

Ext: 4956
Email: sheikhsm@ub.ac.bw
EEB 334: Computer Programming

CHAPTER 6
INTRODUCTION TO OBJECTS AND CLASSES
Streams and Basic File I/O
• A stream is a flow of characters. If the flow is into your program, the stream is
called an input stream.
• If the flow is out of your program, the stream is called an output stream
• If the input stream flows from the keyboard, then your program will take input
from the keyboard. If the stream flows from a file, then your program will take its
input from that file.
• The cin is an input stream connected to the keyboard and cout is an output
stream connected to the screen.
Why Use Files for I/O
• The keyboard input and screen output deal with temporary data.
• File provides means of storing the data permanently.
• Contents of a file remain until a person or program changes the file.
• An input file can be used over and over again by many programs without the
need to type in the data separately for each program.
• Files also provide a convenient way to deal with large quantities of data.
File I/O
• When your program takes input from a file it is said to be reading from the file
and when your program sends output to a file it is said to be writing to the file.
• In C++, a stream is a special kind of variable known as an object.
• If a stream is to be used to get input from a file, it must be declared.
• The streams cin and cout are already declared for you. If a stream is to be
connect to a file, it must be declare just like any other variable.
• The type for input-file stream variables is named ifstream
• The type for out-file stream variables is named ofstream.
• Thus, you can declare in_stream to be an input stream for a file
and out_stream to be output stream for another file as follows
• The types ifstream and ofstream are defined in the library with
ifstream in_stream;
the header file fstream.h and following directive should be
ofstream out_stream;
included
#include <fstream.h>
• Stream variables, such as in_steram and out_stream declared
above, must each be connected to file.
• This is called opening the file and is done with a function
named open.
in_stream.open(“infile.dat”);
• Once you have declared an input stream variable and

connected it to a file using the open function, your program
can take input from the file using the extraction operator >>.
int one_number, another_number

in_stream >> one_number >> another_number
• An output stream is opened in the same way as what we just described for input
streams. The following declares the output stream out_stream and connects it to
the file name outfile.dat
outfstream. open(“outfile.dat”);
• When used with a stream of type ofstream, the member function open will
create the output file if it does not already exist.
• If the output file does exist, the member function open will discard the contents
of the file, so that the output file is empty after the call to open.
• After a file is connected to the stream out_stream with a call to open, the
program can send output to that file using the insertion operator <<.
• e.g.. the following writes two strings and the contents of the variables
one_number and another_number to the which is connected to the stream
out_stream.
out_stream << “one_number = ” << one_number

<< “another_number = ” << another_number;
• Every file should be closed when your program is finished getting input from the
file or sending output to the file. Closing a file disconnects the stream from the
file.
• A file is closed with a call to the function close.
in_stream.close( );
out_stream.close( );
• The function close takes no arguments.

// Reads three numbers from the file infile.dat, sums the numbers,
//and writes the sum to the file outfile.dat.
#include <fstream.h>
int main()
{
ifstream in_stream;
in_stream.open(“infile.dat”);
out_stream.open(“outfile.dat”);
int first, second, third;

in_stream >> first >> second >> third;
out_stream << “The sum of the first 3\n”
<< “numbers in infile.dat\n”
<< “is ” << (first + second + third)
<< endl;
in_stream.close( );
out_steam.close( );
return 0;
}
Introduction to classes and Objects
• The streams in_stream, out_stream, cin and cout are objects.

• An object is a variable that has functions as well as data
associated with it.
• E.g. the streams in_stream and out_stream both have a
function named open associated with them.
• A function that is associated with an object is called a member
function.
• E.g. open is a member function of the object in_stream and
another function named open is a member of the object
out_stream.
• Suppose you declare the following stream objects:
ifstream in_stream, in_stream2;
ofstream out_stream, out_stream2
• The functions in_stream.open and in_stream2.open are the same function.

• Similarly out_stream.open and out_stream2.open are the same function.
• A type whose variables are objects, e.g. ifstream and ofstream is called a class.
Tools for Stream I/O
Formatting Output with Stream Functions
• The layout of a program’s output is called format of the output. E.g. the magic
formula
cout.set(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(1);
• If your program is sending output to a file that is connected to an output stream
called out_stream, you can use these same commands to ensure that numbers
with decimal point will be written in a way we normally write amounts of money.
• Just insert the following in your program
out_stream.set(ios::fixed);
out_stream.setf(ios::showpoint);
out_stream.precision(1);
• The other formatting instructions in our magic formula are:
• Setf is an abbreviation for set flags. A flag is an instruction to do something in one
of the two possible ways. If the flag is given as an argument to setf, then the flag
tells the computer to write output to that stream in some specific way. What it
causes the stream to do depends on the flag.
• In the above example, there are two calls to the function setf and these two calls
set the two flags ios::fixed and ios::showpoint.
• The flag ios::fixed causes the stream to output numbers of type
double in what is called fixed-point notation.
• If the flag ios::fixed is set, then all floating point numbers that are
output to that stream will be written in ordinary everyday notation.
• The flag ios::showpoint tells the stream to always include a decimal
point in floating point numbers
• Another useful flag is ios::showpos. If this flag is set for a stream, then
positive numbers output to that stream will be written with the plus
sign in front of them, e.g.
• The width function tells the stream how many spaces to use when
giving an item as output.
cout.setf(ios::showpos);
cout.width(4);
Character I/O
The member Functions get and put
• The function get allows your program to read in one character

of input and store it in a variable of type char.
• Every input stream, whether it is an input-file stream or the
stream cin, has get as a member function.
char c1, c2, c3;

cin.get(c1);
cin.get(c2);
cin.get(c3)
Whats the output when AB is typed?

• The function put is analogous to the member function get except that it is used
for output rather than input.
• Put allows your program to output one character.
Syntax:
Output_Stream.put (Char_expression);
Examples:
cout.put(next_symbol;
cout.put(‘a’)
Inheritance
• One of the most powerful features of C++ is the use of derived
classes. A derived class is obtained from another class by
adding features.
• E.g the class of input-file streams is derived from the class of all
input streams by adding additional member functions such as
open and close.
• The cin belongs to the class of all input streams, but does not
belong to the class of input-file streams because cin has no
member functions named open and close.
• The word inheritance is just another name for the topic of
derived classes.
Inheritance among Stream Classes
• Recall that an object is a variable that has member functions.
• A class is a type whose variables are objects.
• Streams are objects, so streams types such as ifstream and ofstream are classes.
• An input-file stream can be connected to a file using the member function open,
but the stream cin has no member function named open.
• An input-file is a similar but different kind of stream than cin.
• An put-file stream is of type ifstream.
• cin is of type istream.
• The classes ifstream and istream are different but closely related types.
• The class ifstream is a derived class of the class istream.
• Consider the following function, which reads two integers from the input stream
source_file and writes their sum to the screen:
void two_sum(ifstream& source_file)

{
int n1, n2;
source_file >> n1 >> n2;
cout << n1 “ + ” << n2 << “ = ” << (n1 + n2) << endl;
}
• Suppose your program contains the above function definition and the following
stream declaration
Ifstream fin;
• If fin is connected to a file with a call to open, you can use the function two_sum
to read two integers from that file and write their sum to the screen. The call
would be the following
two_sum(fin)
• Suppose that later on in the same program, you want your program to read two
numbers from the keyboard and write their sum to the screen.
• Since all input streams are similar, you might think you can use cin as the
argument in a second call to two_sum as shown below:
two_sum(cin); // WILL NOT WORK

• cin is not of type ifstream; cin is of type istream. If you want to use cin as an
argument to a function, then the corresponding function parameter should be of
type istream.
• The following rewritten version of two_sum will accept cin as its argument
void better_two_sum(istream& source_file)
{
int n1, n2;
source_file >> n1 >> n2;
cout << n1 “ + ” << n2 << “ = ” << (n1 + n2) << endl;
}
• The following function call can be used
better_two_sum(cin);
• The following is also legal
better_two_sum(fin);
• The type ifstream is a derived class of the class istream.
• When we say that some class A is a derived class of some other class B, it means
that class A has all the features of class B but it also has extra added features.
• E.g. Any stream of type istream can be used with the extraction operator >>.
• The class ifstream is a derived class of the class istream, so an object of type
ifstream can be used with the extraction operator >>.
• One added feature is that a stream of type ifstream can be used with the function
open.
• Derived classes are often discussed using the metaphor of inheritance and family
relationships.
• If class B is a derived class of class A, then class B is called a child of class A and
class A is called a parent of class B.
• The derived class is said to inherit the member functions of its parent class.
• E.g Every input-file stream inherits the extraction operator >> from the class of all
input streams. This is why the topic of derived classes is often called inheritance.

EEB 334 - Chapter 6

Uploaded by

Copyright:

Available Formats

EEB 334 - Chapter 6

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

EEB 334 - Chapter 6

Uploaded by

Copyright:

Available Formats

Dr. Sajid M.

Office No: 248/106

EEB 334: Computer Programming

• Once you have declared an input stream variable and

int one_number, another_number

out_stream << “one_number = ” << one_number

• The function close takes no arguments.

int first, second, third;

• The streams in_stream, out_stream, cin and cout are objects.

• The functions in_stream.open and in_stream2.open are the same function.

• The function get allows your program to read in one character

char c1, c2, c3;

Whats the output when AB is typed?

void two_sum(ifstream& source_file)

two_sum(cin); // WILL NOT WORK

You might also like