

CS201
Introduction to Programming
Lecture
Handout
Introduction
to Programming
Lecture
No. 44
Reading
Material
Lecture
25  Lecture 43
Summary
·
Matrix
Class
·
Definition
of Matrix Constructor
·
Destructor of
Matrix Class
·
Utility
Functions of Matrix
·
Input
Function
·
Transpose
Function
·
Code of
the Program
Matrix
Class
After
talking at length about the
concept of matrices in the
previous lecture, we are
going
to have a
review of `code' today with
special emphasis on concepts of
constructors and
destructors.
We may also briefly discuss
where should a programmer return by
value,
return by
reference besides having a cursory
look on the usage of the
pointers.
The
data structure of the Matrix
class is
very simple. We have defined an
arbitrary
number of
functions and operators. You
may add and subtract more
functions in it. In this
lecture,
we have chosen just a few as it is
not possible to discuss each
and every one in a
brief
discourse. As discussed earlier,
the code is available to use
that can be compiled
and
run.
This class is not complete
and a lot of things can be
added to it. You should
try to
enhance
it, try to improve and
add to its
functionality.
One of
the things that a programmer will
prefer to do with this class
is its templatization.
We have
implemented it for type double. It was
done due to the fact that
the elements of
the
Matrix
are of
type double. You
may like to improve and
make it a templatized class
so that
it can also handle integer
elements. This class is
written in a very
straightforward
manner.
The double
is
used only for elements to
develop it into a Matrix
class
for
integers
if you replace all the
double
word
with the int. Be careful,
you cannot revert it
Page
561
CS201
Introduction to Programming
back to
double
by
just changing all the
int
to
double
as
integers are used other
than
element
types.
Let's
discuss the code beginning
with the data structure of
the class. In keeping
the
concepts
of data hiding and
encapsulation, we have put
the data in the private
section of
the
class. We
have defined number of rows
(i.e. numRows) and
number of columns (i.e.
numCols) as
integers. These will always
be whole number. As we cannot
have one and a
half
row or column, so these are
integers.
The
private part of the Matrix
class
is:
int
numRows, numCols;
double
**elements;
These
are fixed and defined. So
whenever you have an object of
this class, it will have
a
certain
number of rows and certain
number of columns. These are
stored in the
variables
numRows
and
numCols. Where
will be the values of the
elements of this matrix?
The
next
line is double
**elements; i.e. elements
is an
array of pointers to double. First *
is
for
array and second * makes it
a pointer. It means that `elements'
is
pointing to a two
dimension
array of double. When we
say elements[i], it
means that it is pointing to
an
array of
double. If we
say elements[i][j], it
means we are talking about a
particular
element
of type double. We have
not taken the twodimension
array in the usual way
but
going to
dynamic memory allocation. We have
developed a general Matrix
class.
The
objects
created from it i.e. the
instances of this class, could be
small matrices as 2*2.
These
may also be as big matrix as
20*20. In other words, the
size of the matrix is
variable. In fact,
there is no requirement that size
should be square. It may not
be 20*20.
It may be
a matrix of 3*10 i.e. three
rows and ten columns. So we
have complete
flexibility.
When we create an object, it will store
the number of rows in numRows
and
number of
columns in numCols. The
elements will be dynamically
allocated memory in
which
the double
value is
stored.
While
using the dynamic memory, it
is good to keep in mind that
certain things are
necessary
to be implemented in the class. 1) Its
constructor should make
memory
allocation. We
will use the new
operator,
necessitating the need of
defining its
destructor
also.
Otherwise, whenever we create an object,
the memory will be allocated
from the
free
store and not deallocated
resulting in the wastage of the
memory. Therefore a
destructor
is necessary while deallocating memory.
2) The other thing while
dealing
with
classes having dynamic memory allocation,
we need to define an assignment
operator.
If we do not define the assignment
operator, the default will do
the member
wise copy
i.e. the shallow copy. The
value of pointer will be copied to
the pointer but the
complete
data will not be copied. We
will see in the code
how can we overcome
this
problem..
Let's
discuss the code in the
public interface of the
class. The first portion of
the public
interface
is as:
Page
562
CS201
Introduction to Programming
Matrix(int=0,
int=0);
// default
constructor
Matrix(const
Matrix & ); // copy
constructor
~Matrix();
//
Destructor
In the
public interface, the first
thing we have is the
constructors. In the default
constructor,
you see the number of
columns and number of rows.
The default values
are
zero. If
you just declare a matrix as
Matrix
m, it
will be an object of class Matrix
having
zero
rows and zero columns i.e.
memory is not allocated yet.
Then we have also written
a
copy
constructor. Copy constructor
becomes necessary while dealing
with dynamic
memory
allocation in the class. So we have to
provide constructor, destructor,
assignment
operator
and the copy constructor.
The declaration line of copy
constructor is always
the
same as
the name of the class. In
the argument list, we have a
reference to an object of
the
same class i.e. Matrix(const
Matrix
&
); The & represents the
reference. This is
the
prototype.
After constructors, we have
defined a destructor. Its prototype is
also standard.
Here it is
~Matrix(); it
takes no argument and
returns nothing. Remember
that
constructors
and destructors return
nothing.
After
this, we have utility functions for
the manipulation of the Matrix.
int
getRows(void) const;
//
Utility fn, returns no. of
rows
int
getCols(void) const;
//
Utility fn, returns no. of
columns
const
Matrix & input(istream &is = cin); //
Read from istream i.e.
keyboard
const
Matrix & input(ifstream
&is);
// Read
matrix from ifstream
void
output(ofstream &os) const;
//
Utility fn, prints matrix
with graphics
void
output(ostream &os = cout) const; //
Utility fn, prints matrix
with graphics
const
Matrix& transpose(void);
//
Transpose the matrix and
return a ref
We have
defined two small functions as
getRows
and
getCols
which
will return the
number of
rows and number of columns of
the matrix respectively. Here, you
are writing
the
class and not the
client which will use this
class. During the usage of
this class, there
may be
need of some more functions. You
may need to add some more
functionality
depending
on its usage. At this point,
a function may be written
which will return
some
particular
row as a vector or the nth
column of a matrix. These things
are left for you
to
do.
We need
some function to input
values into the matrix.
There are two input
functions
both
named as input. One is
used to get the value
from the keyboard while
the other to
get
the values from some
file. There is a little bit
difference between the declaration
of
these
two that will be discussed
later. The input
function
which will get the
input from
the
keyboard, takes an argument of
type istream.
Remember that cin,
that is
associated
with
the keyboard, is of type istream. These
are member functions and called by
some
object of
Matrix. The
Matrix
object
will be available to it through this
pointer.
The
Page
563
CS201
Introduction to Programming
istream
is
passed as argument and we
have given a temporary name to the
input argument
i.e. is
and
its default value is cin. It is a nice
way of handling default values. If you
write
in the
main program as m.input()
where
m
is an
object of type Matrix, it will
get the input
from
the keyboard. This is due to
the fact that it is getting cin
by
default. We have
defined
another input
function
and that is an example of function
overloading. This
function
takes ifstream
as
input argument i.e. a file
stream. If we want to read
the matrix
data
from some file, this
input
function
may be employed. There is no default
argument
in
it.
Similarly
we have two output
functions.
The names are chosen as
arbitrary. You may
want to
use print or display. One
output function will display
the matrix on the screen.
Its
argument
is ostream
while
the default value will be cout. The
other output function
will
be used
when we want to write the
matrix in some file. It
takes ofstream
as
argument and
we have
not provided any default argument to
it. You will have to provide
a file handle to
use
this function.
Let's
continue to talk about the
arithmetic manipulations we want to do
with the matrices.
Matrix
operator+( Matrix &m) const; //
Member op + for A+B; returns
matrix
Matrix
operator + (double d)
const;
// Member
op + for A+d; returns
matrix
const
Matrix & operator += (Matrix &m);
// Member op += for A
+=B
friend
Matrix operator + (double d,
Matrix &m); // friend operator
for d+A
Matrix
operator( Matrix & m) const; //
Member op  for AB; returns
matrix
Matrix
operator  (double d)
const;
// Member
op  for Ad;
const
Matrix & operator = (Matrix &m);
// Member op = for
A=B;
friend
Matrix operator  (double d, Matrix&
m); // Friend op  for
dA;
Matrix
operator*(const Matrix & m); //
Member op * for A*B;
Matrix
operator * (double d) const; //
Member op * for A*d;
friend
Matrix operator * (const
double d, const Matrix& m);//friend
op*, d*A
const
Matrix& transpose(void); // Transpose
the matrix and return a
ref
const
Matrix & operator = (const
Matrix &m); // Assignment
operator
We have
defined different functions for plus.
Some of these are member
operators while
the
others called as friend. The
first plus operator is to add
two matrices. It is a member
operator
that takes a Matrix
object as
argument. The second one is
to add some double
number to
matrix. Remember that we are
having a class of Matrix
with
double
elements.
So we
will add double
number to
it. It is also a member operator. When
you write
something
like m +
d,
where m
is an
object of type Matrix
and
d
is a
double
variable,
this
operator
will be called. Here Matrix
object is
coming on the lefthand side
and will be
available inside
the operator definition by
this pointer. On the other
hand, the double
value
d
is
presented as argument to the
operator.
Page
564
CS201
Introduction to Programming
There is
another variety of adding
double to the matrix i.e. if we
write as d +
m. On
the
lefthand
side, we don't have Matrix. It
cannot be a member function as the
driving force
is not an
object of our desired class. If
not a member function, it will
have two arguments.
First
argument will be of type double
while
the second one is going to be of
Matrix
object
in which
we will add the double
number.
As it is not a member function and we
want to
manipulate
the private data members of
the class, it has to be a
friend function. Function
will be
defined outside, at file level
scope. In other words, it
will not be a member
function
of class Matrix
but
declared here as a friend. It is
defined as:
Friend
Matrix operator + (double d,
Matrix &m);
Its
return type is Matrix. When we
add a double
number,
it will remain as Matrix
.We
will be
able to return it. The
final variant is included as an example of code
reuse i.e. the
+=
operator. We write in our program
i += 3;
and it
means i = i +
3; It
would be nice if
we can
write A += B
where
A
and
B
both
are matrices.
After
plus, we can do the same
thing with the minus
operator. Having two
matricesA
and
B, we want
to do AB. On the
left hand side, we have
Matrix, so it
will be a member
operator.
The other matrix will be
passed as argument. In AB,
A is
calling this operator
while
B
being
passed as argument. We can
also do Ad
where
A
is a
Matrix
and
d
is
of
type
double. For this, we will
have to write a member operator. All
these operators are
overloaded
and capable of returning Matrix. In this
overloaded operator, double
will
be
passed as
argument. Then we might want
to do it as d 
A,
where d
is
double
variable
and
A
is of
type Matrix. Since
the left hand side of
the minus () is double, we will
need a
friend
function, as it is not possible to
employ a member function. Its prototype
is as:
friend
Matrix operator  (double d, Matrix&
m);
Let's
now talk about
multiplication. We have discussed
somewhat about it in the
previous
lecture.
For multiplication, the
first thing one needs to do
is the multiplication of
two
matrices
i.e. A*B
where
A
and
B
both
are matrices. As on the left
hand side of the
operator
* we have a Matrix
so it
will be a member function so A
can be
accessed through
this
pointer.
B
will be
passed as argument. A matrix
should be returned. Thus, we
have a
member
operator that takes an
argument of type Matrix
and
returns a Matrix. You
may
like to
do the same thing, which we
did with the plus and
minus. In other words,
a
programmer
will multiply a matrix with
a double
or
multiply a double
with a
matrix. In
either
case, we want that a matrix
should be returned. So at first,
A * d
should be
a
member
function. Whereas d * A
will be a
friend function. Again the
return type will be a
Matrix.
In case
of division, we have only
one case i.e. the division
of the matrix with a double
number.
This is A / d
where
A
is a
Matrix
while
d
is a
double
variable. We
will divide all
the
elements of the matrix with
this double
number.
This will return a matrix of
the same
size as of
original.
Page
565
CS201
Introduction to Programming
Taking
benefit of the stream insertion and
extraction operator, we can use
double greater
than sign
( >>) and write as >> m
where
m
is a
Matrix. For
this purpose, we have
written
stream
extraction operator. The insertion
and extraction functions will be
friend functions
as on the
lefthand side, there will be
either input stream or output
stream.
We have
also defined assignment
function in it. As we are
using dynamic memory
allocation in
the class, assignment is an
important operator. Another important
function is
transpose,
in which we will interchange
the rows into columns and
return a Matrix.
This
is the
interface of our Matrix
class.
You may want to add
other functions and
operators
like
+=, =, *=. But it is
not possible to add /= due
to its very limited
scope.
We have
used the keyword const in
our class. You will
find somewhere the return
type as
Matrix
and
somewhere as Matrix
&. We
will discuss each of these
while dealing with
the
code in detail.
Definition
of Matrix Constructor
Let's
start with the default
constructor. Its prototype is as
under:
Matrix(int
= 0, int = 0);
// default
constructor
We are
using the default argument
values here. In the
definition of this function, we
will
not
repeat the default values.
Default values are given at
one place. The definition
code is
as:
Matrix::Matrix(int
row, int col)
//default
constructor
{
numRows =
row;
numCols =
col;
elements
= new (double *)
[numRows];
for
(int i = 0; i < numRows;
i++){
elements[i]
= new double [
numCols];
for(int j
= 0; j < numCols; j++)
elements[i][j]
=0.0; // Initialize to
zero
}
}
Two
integers are passed to it.
One represents the number of
rows while the other
is
related
to the number of columns of the
Matrix
object
that we want to create. At
first,
we will
assign these values to numRows
and
numCols
that
form a part of the
data
structure
of our class. Look at the
next line. We have declared
elements
as
**elements
i.e.
the
array of pointers to double. We can
directly allocate it by getting the
elements of
Page
566
CS201
Introduction to Programming
numRows
times
numCols
of
type double
from
free store. But we don't
have the double
pointer.
Therefore, first of all, we
say that element is array of
pointer to double
and
allocate
pointers as much as needed. So we
use the new
operator
and use double*
cast.
It
means
that whatever is returned is of type
pointer to double. How
many pointers we
need?
This is equal to number of
rows in the matrix. There is
one pointer for each of
the
rows i.e.
now a row can be an array.
This is a favorable condition, as we have
to enter
data in
the columns. Now elements
is
numRows
number of
pointers to double.
After
having
this allocation we will run
a loop.
In C/C++
languages, every row starts
from zero and ends
with upperlimit
1. Now
in
the loop,
we have to allocate the
space for every elements[i];
How much
space is needed
here?
This will be of type double
and
equal to number of columns. So when we
say new
double[numCols],
it
means an array of double. As elements[i]
represents
a pointer and
now it is
pointing to an array. Remember
that pointers and arrays
are synonymous. Now
a pointer is
pointing to this array. We
have the space now
and want to initialize
the
matrix.
For this, we have written
another loop. To assign the
value, we will write
as:
elements[i][j]
= 0.0;
Let's
review this again. First of
all we have assigned the
values to numRows
and
numCols. Later,
we allocated the pointers of
double
from
the free store and
assigned to
elements. Then we
got the space for
each of this pointer to store
double.
Finally, we
initialized
this space with 0.0.
Now we have a constructive
matrix.
Is there
any exceptional value? We can
think of assigning negative
values to number of
rows or
number of columns. If you want to
make sure that this does
not happen, you
can
put a
test by saying that numRows
and
numCols
must
be greater than or equal to
zero.
Passing
zero is not a problem as we have
zero space and nothing
happens actually. Now
we get an
empty matrix of dimension 0*0.
But any positive number
supplied will give us
a
constructor and initialize
zero matrix.
Let's
discuss the other
constructor. This is more
important in the view of
this class
especially at a
time when we are going to do
dynamic memory allocation. This is
copy
constructor.
It is used when we write in
our program as Matrix
A(B); where A
and
B
both
are
matrices. We are going to construct A
while
B
already
exists. Here we are saying
that
give us a
new object called A
which
should be identical to the
already existing object B.
So it is a copy
constructor. We are constructing an object as a copy
of another one that
already
exists. The other usage of
this copy constructor is writing in
the main function as
Matrix
A = B; Remember
that this is declaration and
not assignment statement.
Here
again
copy constructor will be called. We are
saying that give us a duplicate of B
and
its
name
should be A.
Here is
the code of this
function:
Matrix::Matrix(const
Matrix &m)
{
numRows =
m.numRows;
numCols =
m.numCols;
Page
567
CS201
Introduction to Programming
elements
= new (double *)
[numRows];
for
(int i = 0; i < numRows;
i++){
elements[i]
= new double [
numCols];
for(int j
= 0; j < numCols; j++)
elements[i][j]
= m.elements[i][j];
}
}
We are
passing it a constant reference of
Matrix
object to
ensure that the matrix to
be
copied is
not being changed. Therefore
we make it const. We are
going to create a brand
new
object that presently does
not exist. We need to repeat
the code of regular
constructor
except the initialization
part. Its rows will be
equal to the rows of the
object
supplied i.e.
numRows
= m.numRows.
Similarly the columns i.e. numCols=
m.numCols.
Now we
have to allocate space while
using the same technique
earlier employed in case
of the
regular constructor. In the default
constructor, we initialize the
elements with zero.
Here we
will not initialize it with
zero and assign it the
value of Matrix
m as
elements[i][j]
= m.elements[i][j].
Remember that we use the
dot operator to access
the
data
members. We have not used
the dot operator on the
left hand side. This is
due to the
fact that
this object is being constructed
and available in this function
through this
pointer.
Therefore the dot operator
on the left hand side is
not needed. We will use it
on
the
right hand side to access
the data members of Matrix
m.
This is our copy
constructor.
In this
function, we have taken the
number of rows and columns of
the object whose copy
is being
made. Then we allocate it
the space and copy the
values of elements one by
one.
The
other thing that you
might want to know is the
use of nested loop both in
regular
constructor
and the copy
constructor.
Destructor
of Matrix Class
`Destructor'
is relatively simple. It becomes
necessary after the use of
new in the
constructor.
While creating objects, a programmer
gets memory from the
free store. So in
the
destructor, we have to return
it. We will do it as:
delete []
elements;
Remember
that `elements' is the
variable where the memory has
been allocated. The
[]
simply,
indicates that it is an array.
The compiler automatically
takes care of the size
of
the
array and the memory
allocated after being
returned, goes back to the
free store.
There is
only one line in the
destructor. It is very simple
but necessary in this
case.
Utility
Functions of Matrix
The
functions getRows()
and
getCols()
are
relatively simple. They do not
change
anything in
the object but only read
from the object. Therefore we
have made this
function
constant by writing the const
keyword
in the end. It means that it
does not
change
anything. The code of the getRows()
functions is as
follows:
int
Matrix :: getRows ( ) const
{
Page
568
CS201
Introduction to Programming
return
numRows;
}
This
function returns an int
representing
the number of rows. It will
be used in the main
function
as i =
m.getRows(); where i
is an
int
and
m
is a
Matrix
object.
Same thing
applies
to the getCols()
function.
It is of type const
and
returns an int
representing
the
number of
columns.
Let's
talk about little bit
more complicated function. It is the
output to the screen
functions. We
want that our matrix
should be displayed on the screen in a
beautiful way.
You
have seen that in the
books that matrix is written
in big square brackets. The
code of
the
function is as:
void
Matrix::output(ostream &os)
const
{
// Print
first row with special
characters
os.setf(ios::showpoint);
os.setf(ios::fixed,ios::floatfield);
os <<
(char) 218;
for(int j
= 0; j < numCols; j++)
os << setw(10)
<< " ";
os <<
(char) 191 <<
"\n";
// Print
remaining rows with vertical
bars only
for
(int i = 0; i < numRows;
i++){
os <<
(char) 179;
for(int j
= 0; j < numCols; j++)
os <<
setw(10)<< setprecision(2) <<
elements[i][j];
os <<
(char) 179 <<
"\n";
}
// Print
last row with special
characters
os <<
(char) 192;
for(int j
= 0; j < numCols; j++)
os << setw(10)
<< " ";
os <<
(char) 217 <<
"\n";
}
We have
used special characters that
can be viewed in the command
window. We have
given you
an exercise of printing the
ASCII characters on the
screen. After ASCII
code
128, we
have special graphic symbols. We have
used the values of those
symbols here.
To print
those in the symbol form, we
have forced it to be printed as char. If we do
not
use
the char, it
would have printed the
number 218 i.e. it would
have written an
integer.
Page
569
CS201
Introduction to Programming
We have
forced it to print the
character whose ASCII value
is 218. Now it prints
the
graphic
symbol for that character.
We have referenced the ASCII
table and seen
which
symbol
will fit in the left
corner i.e. 218. So we have
written it as:
os <<
(char) 218;
os
is
the output stream. char
is
forcing it to be print as character.
The left corner will
be
printed on
the screen as . Now we
need the space to print
the columns of the matrix.
In
the
first line we will print
the spaces using a loop
as:
for(int j
= 0; j < numCols; j++)
os << setw(10)
<< " ";
Here we
have changed the width as
10. You can change it to
whatever you like. Then
we
print
nothing in the space of ten
characters and repeat that
for the number of columns
in
the
matrix. After this, we printed the
right corner. This is the
first line of the
display.
Other
lines will also contain the
values of the elements of
the matrix. These lines
will
start
with a vertical line and
then the element values of
the row and in the
end we have a
vertical
line. For each row, we
have a vertical bar and
the number values which
will be
equal to
number of columns (elements in each
row equals to the number of
columns) and
then a
vertical bar in the end. In
the beginning of this code, we
have used two
other
utilities
to improve the formatting. Here we
have a matrix of type double
so
every
element
of
the
matrix
is
double.
For
double,
we
have
used
os.setf(ios::fixed,ios::floatfield);
that
means that it is a fixed display.
Scientific notation
will
not be used while decimal
number is displayed with the
decimal point. After this,
we
have
set the precision with two
number of places. So we have a
format and our
decimal
numbers
will always be printed with
two decimal places. The
numbers are being
printed
with a
width of ten characters so
the last three places
will be as .xx. Rest of
the code is
simple
enough. We have used the
nested loops. Whenever you
have to use rows
and
columns, it
will be good to use nested
loops. When all the rows
have been printed, we
will
print the below corners. We
referenced the ASCII table,
got the graphic
symbol,
printed
it, left the enough
space and then printed the
other corner. The matrix is
now
complete. When
this is displayed on the screen, it
seems nicely formatted matrix
with
graphic symbols.
That is our basic output
function.
Let's
look at the file output
function. While doing the
output on the screen, we
made it
nicely
formatted. Now you may like
to store the matrix in a
file. While storing the
matrix
in the
file, there is no need of
these lines and graphic
symbol. We only need its
values to
read
the matrix from the
file. So there is a pair of functions i.e. output
the matrix in the
file
and input from the
file. To write the output
function, we actually have to
think about
the
input function.
Suppose,
we have declared a 2*2 Matrix
m in
our program. Somewhere in
the program,
we want
to populate this matrix from
the file. Do we know that we
have a 2*2 matrix in
the
file. How do we know that?
It may 5*5 or 7*3 matrix. So
what we need to do is
somehow
save the number of rows
and columns in the file as
well. So the output
function
Page
570
CS201
Introduction to Programming
that
puts out on the file must
put out the number of
rows and number of columns
and then
all of
the elements of the matrix.
Following is the code of
this function:
void
Matrix::output(ofstream &os)
const
{
os.setf(ios::showpoint);
os.setf(ios::fixed,ios::floatfield);
os <<
numRows << " " << numCols <<
"\n";
for
(int i = 0; i < numRows;
i++){
for(int j
= 0; j < numCols; j++)
os << setw(6)
<< setprecision(2) <<
elements[i][j];
os <<
"\n";
}
}
The
code is shorter than the
other output function due to
nonuse of the graphical
symbols. First of
all, we output the number of
rows and number of columns.
Then for
these
rows and columns, data
elements are written. We
have also carried out a
little bit
formatting.
While seeing this file in
the notepad, you will notice
that there is an extra
line
on the
top that depicts the
number of rows and
columns.
Input
Functions
Input
functions are also of two
types like output functions.
The first function takes
input
from
the keyboard while the
other takes input from
the file. The function
that takes input
from
the keyboard is written in a
polite manner because humans
are interacting with
it.
We will
display at the screen "Input
Matrix size: 3 rows by 3
columns" and it will
ask
"Please
enter 3 values separated by
spaces for row no. 1"
for each row. Spaces
are
delimiter
in C++. So spaces will
behave as pressing enter
from the keyboard. If you
have
to enter
four numbers in a row, you
will enter as number (space)
number (space) number
(space)
number before pressing the
enter key. We have a loop inside
which will process
input
stream and storing these
values into elements[i][j];
So
the difference between
this
function
and the file input
function is 1) It prompts to the user
and is polite. 2) It will
read
from
the keyboard and consider
spaces as delimiter.
The
other input function reads
from the file. We have
also stored the number of
rows and
number of
columns in the file. The
code of this function
is:
const
Matrix & Matrix::input(ifstream
&is)
{
int
Rows, Cols;
is >>
Rows;
is >>
Cols;
Page
571
CS201
Introduction to Programming
if(Rows
> 0 && Cols > 0){
Matrix
temp(Rows, Cols);
*this =
temp;
for(int i
= 0; i < numRows; i++){
for(int j
= 0; j < numCols; j++){
is >>
elements[i][j];
}
}
}
return
*this;
}
First of
all, we will read the
number of rows and number of
columns from the file.
We
have
put some intelligence in it.
It is better to check whether numRows
and
numCols
is
greater
than zero. If it is so, then
do something. Otherwise, there is nothing to do. If
rows
and
columns are greater than
zero, then there will be a
temporary matrix specifying
its
rows
and columns. These values
are read from the
file, showing that we have a
matrix of
correct
size. Now this matrix is
already initialized to zero by
our default constructor. We
can do
two things. We can either
read the matrix, return
the value or we can first
assign it
to the
matrix that was calling this
function. We have assigned it
first as *this
= temp; here
temp
is a
temporary matrix which is created in
this function but *this
is
whatever this
points to.
Remember that this is a member
function so this
pointer points to
the matrix
that is
calling this function. All we
have to do is to assign the
temp
to
the matrix, which is
calling
this function. This equal to
sign is our assignment operator,
which we have
defined
in our Matrix
class. If
the dimensions of the calling
matrix are not equal to
the
temp
matrix,
the assignment operator will
correct the dimensions of the
calling matrix. It
will
assign the values, which in
this case is zero so far.
Now we will read the
values from
the
file using the nested
loops. The other way is to
read the values from
the file and
populate
the temp
matrix
before assigning it to the
calling matrix in the end.
That is the
end of
the function. Remember that
the temp
matrix,
which we have declared in
this
function,
will be destroyed after the
exit from the function.
This shows that the
assignment
operator is important here. All
the values will be copied
and it will perform a
deep
copy. Does this function
return something? Its return
type is reference to a const
Matrix. Its
ending line is return *this
that
means return whatever this
points to
and it is
returned
as reference. The rule of thumb is
whenever we are returning the
this
pointer,
it
will be
returned as a reference because
this is the same object
which is calling it.
When
you are
returning a matrix that is not a
reference, it is a returned by value.
The complete
matrix
will be copied on the stack
and returned. This is
slightly wasteful. Yet you
cannot
return a
reference to the temp
object in this
code. The reference of the
temp
will
be
returned
but destroyed when the
function is finished. The reference
will be pointing to
nothing. So
you have to be careful while returning a
reference to this.
Transpose
Function
The
transpose of a matrix will
interchange rows into columns.
There are two
alternative
requirements.
In the first case, we have a
square matrix i.e. the
number of rows is equal
to
Page
572
CS201
Introduction to Programming
number of
columns. In this situation, we don't need
extra storage to do this. If the
number
of rows
is not equal to the number
of columns, then we have to deal it in a
different way.
We can
use general case for
both purposes but you
will notice that it is
slightly
insufficient.
Here is the code of the
function.
const
Matrix & Matrix::transpose()
{
if(numRows
== numCols){ // Square
matrix
double
temp;
for(int i
= 0;i < numRows;
i++){
for(int j
= i+1; j < numCols;
j++){
temp =
elements[i][j];
elements[i][j]
= elements[j][i];
elements[j][i]
= temp;
}
}
}
else //
not a square matrix
{
Matrix
temp(numCols, numRows);
for(int i
= 0; i < numRows; i++){
for(int j
= 0; j < numCols; j++){
temp.elements[j][i]
= elements[i][j];
}
}
*this =
temp;
}
return
*this;
}
In the
beginning, we checked the case of
square matrix i.e. if the
number of rows is
equal
to number
of columns. Here we are dealing with the
square matrix. We have to
change
the
rows into columns. For this
purpose, we need a temporary variable. In
this case, it is a
variable of
type double
because
we are talking about a double
matrix.
Look at the loop
conditions
carefully. The outer loop
runs for i = 0
to
i <
numRows and
the inner loop
runs
from j =
i+1 to j <
numCols. Then we
have standard swap functionality. We
have
processed
one triangle of the matrix. If
you start the inner loop
from zero, think
logically
what
will happen. You will
interchange a number again
and again, but nothing
will
happen in
the end, leaving no change
in the matrix. This is the
case of the square
matrix.
But in
case of nonsquare matrix i.e.
the code in the else
part, we have to define a
new
matrix.
Its rows will be equal to
the columns of the calling
matrix and its columns will
be
equal to
the number of rows. So we
have defined a new Matrix
temp with
the number of
rows
and columns interchanged as compared to
the calling matrix. Its
code is
straightforward. We
are doing the element to
element copy. The difference is, in the
loop
we are
placing the x
row, y col element
of the calling matrix to y
row, x col of the
temp
matrix.
It is an interchange of the rows
and columns according to the
definition of the
Page
573
CS201
Introduction to Programming
transpose.
When we have all the values
copied in the temp. We do
our little magic that
is
*this
= temp. Which
means whatever this
points to,
now assigned the values of
the matrix
temp. Now
our horizontal matrix
becomes vertical and vice
versa. In the end, we
return
this. This is
the basic essence of
transpose code.
We will
continue the discussion on the
code in the next lecture. We
will look at the
assignment
operator, stream operator
and try to recap the
complete course.
Code of
the Program
The
complete code of the matrix
class is:
#include
<iostream.h>
#include
<iomanip.h>
#include
<stdlib.h>
#include
<stdio.h>
#include
<fstream.h>
class
Matrix
{
private:
int
numRows, numCols;
double
**elements;
public:
Matrix(int=0,
int=0);
// default
constructor
Matrix(const
Matrix & );
// copy
constructor
~Matrix();
//
Destructor
int
getRows(void) const;
//
Utility fn, returns no. of
rows
int
getCols(void) const;
//
Utility fn, returns no. of
columns
const
Matrix & input(istream &is = cin); //
Read matrix from
istream
const
Matrix & input(ifstream
&is);
// Read
matrix from istream
void
output(ofstream &os) const;
//
Utility fn, prints matrix
with graphics
void
output(ostream &os = cout) const; //
Utility fn, prints matrix
with graphics
const
Matrix& transpose(void);
//
Transpose the matrix and
return a ref
const
Matrix & operator = (const
Matrix &m);
// Assignment
operator
Matrix
operator+( Matrix &m)
const;
// Member
op + for A+B; returns
matrix
Matrix
operator + (double d)
const;
const
Matrix & operator += (Matrix
&m);
friend
Matrix operator + (double d,
Matrix &m);
Matrix
operator( Matrix & m)
const;
// Member
op + for A+B; returns
matrix
Matrix
operator  (double d)
const;
const
Matrix & operator = (Matrix
&m);
Page
574
CS201
Introduction to Programming
friend
Matrix operator  (double d, Matrix&
m);
Matrix
operator*(const Matrix & m);
Matrix
operator * (double d)
const;
friend
Matrix operator * (const
double d, const Matrix&
m);
Matrix
operator/(const double d);
friend
ostream & operator << ( ostream
& , Matrix & );
friend
istream & operator >> ( istream & ,
Matrix & );
friend
ofstream & operator << (
ofstream & , Matrix & );
friend
ifstream & operator >> (
ifstream & , Matrix & );
};
Matrix::Matrix(int
row, int col)
//default
constructor
{
numRows =
row;
numCols =
col;
elements
= new (double *)
[numRows];
for
(int i = 0; i < numRows;
i++){
elements[i]
= new double [
numCols];
for(int j
= 0; j < numCols; j++)
elements[i][j]
= 0; // Initialize to zero
}
}
Matrix::Matrix(const
Matrix &m)
{
numRows =
m.numRows;
numCols =
m.numCols;
elements
= new (double *)
[numRows];
for
(int i = 0; i < numRows;
i++){
elements[i]
= new double [
numCols];
for(int j
= 0; j < numCols; j++)
elements[i][j]
= m.elements[i][j];
}
}
Matrix::~Matrix(void)
{
delete []
elements;
}
int
Matrix :: getRows ( ) const
{
return
numRows;
Page
575
CS201
Introduction to Programming
}
int
Matrix :: getCols ( )
const
{
return
numCols;
}
void
Matrix::output(ostream &os)
const
{
// Print
first row with special
characters
os.setf(ios::showpoint);
os.setf(ios::fixed,ios::floatfield);
os <<
(char) 218;
for(int
j=0; j<numCols;
j++)
os << setw(10)
<< " ";
os <<
(char) 191 <<
"\n";
// Print
remaining rows with vertical
bars only
for
(int i=0; i<numRows;
i++){
os <<
(char) 179;
for(int
j=0; j<numCols;
j++)
os <<
setw(10)<< setprecision(2) <<
elements[i][j];
os <<
(char) 179 <<
"\n";
}
// Print
last row with special
characters
os <<
(char) 192;
for(int
j=0; j<numCols;
j++)
os << setw(10)
<< " ";
os <<
(char) 217 <<
"\n";
}
void
Matrix::output(ofstream &os)
const
{
os.setf(ios::showpoint);
os.setf(ios::fixed,ios::floatfield);
os <<
numRows << " " << numCols <<
"\n";
for
(int i=0; i<numRows;
i++){
for(int
j=0; j<numCols;
j++)
os << setw(6)
<< setprecision(2) <<
elements[i][j];
os <<
"\n";
}
}
const
Matrix & Matrix::input(istream
&is)
{
cout
<< "Input Matrix size: " <<
numRows << " rows by " <<
numCols << "
Page
576
CS201
Introduction to Programming
columns\n";
for(int
i=0; i<numRows;
i++){
cout
<< "Please enter " << numCols
<< " values separated by spaces
for row
no."
<< i+1 << ": ";
for(int
j=0; j<numCols;
j++){
cin
>> elements[i][j];
}
}
return
*this;
}
const
Matrix & Matrix::input(ifstream
&is)
{
int
Rows, Cols;
is >>
Rows;
is >>
Cols;
if(Rows>0
&& Cols > 0){
Matrix
temp(Rows, Cols);
*this =
temp;
for(int
i=0; i<numRows;
i++){
for(int
j=0; j<numCols;
j++){
is >>
elements[i][j];
}
}
}
return
*this;
}
const
Matrix & Matrix::transpose()
{
if(numRows
== numCols){ // Square
matrix
double
temp;
for(int
i=0; i<numRows;
i++){
for(int
j=i+1; j<numCols;
j++){
temp =
elements[i][j];
elements[i][j]
= elements[j][i];
elements[j][i]
= temp;
}
}
}
else
{
Matrix
temp(numCols, numRows);
for(int
i=0; i<numRows;
i++){
for(int
j=0; j<numCols;
j++){
temp.elements[j][i]
= elements[i][j];
Page
577
CS201
Introduction to Programming
}
}
*this =
temp;
}
return
*this;
}
const
Matrix & Matrix :: operator = (
const Matrix & m )
{
if(
&m != this){
if
(numRows != m.numRows  numCols !=
m.numCols){
delete []
elements;
elements
= new (double *)
[m.numRows];
for
(int i = 0; i < m.numRows;
i++)
elements[i]=new
double[m.numCols ];
}
numRows =
m.numRows;
numCols =
m.numCols;
for (
int i=0; i<numRows;
i++){
for(int
j=0; j<numCols;
j++){
elements[i][j]
= m.elements[i][j];
}
}
}
return
*this;
}
Matrix
Matrix::operator + ( Matrix &m )
const
{
// Check
for conformability
if(numRows
== m.numRows && numCols ==
m.numCols){
Matrix
temp(m);
for
(int i = 0; i < numRows;
i++){
for
(int j = 0; j < numCols;
j++){
temp.elements[i][j]
+= elements[i][j];
}
}
return
temp ;
}
}
Matrix
Matrix::operator + ( double d )
const
{
Matrix
temp(*this);
for
(int i = 0; i < numRows;
i++){
for
(int j = 0; j < numCols;
j++){
Page
578
CS201
Introduction to Programming
temp.elements[i][j]
+= d;
}
}
return
temp ;
}
const
Matrix & Matrix::operator += (Matrix
&m)
{
*this =
*this + m;
return
*this;
}
Matrix
Matrix::operator  ( Matrix &m )
const
{
// Check
for conformability
if(numRows
== m.numRows && numCols ==
m.numCols){
Matrix
temp(*this);
for
(int i = 0; i < numRows;
i++){
for
(int j = 0; j < numCols;
j++){
temp.elements[i][j]
= m.elements[i][j];
}
}
return
temp ;
}
}
Matrix
Matrix::operator  ( double d )
const
{
Matrix
temp(*this);
for
(int i = 0; i < numRows;
i++){
for
(int j = 0; j < numCols;
j++){
temp.elements[i][j]
= d;
}
}
return
temp ;
}
const
Matrix & Matrix::operator = (Matrix
&m)
{
*this =
*this  m;
return
*this;
}
Matrix
Matrix::operator* ( const Matrix&
m)
{
Matrix
temp(numRows,m.numCols);
Page
579
CS201
Introduction to Programming
if(numCols
== m.numRows){
for (
int i = 0; i < numRows;
i++){
for (
int j = 0; j < m.numCols;
j++){
temp.elements[i][j]
= 0.0;
for(
int k = 0; k < numCols;
k++){
temp.elements[i][j]
+= elements[i][k] *
m.elements[k][j];
}
}
}
}
return
temp;
}
Matrix
Matrix :: operator * ( double d)
const
{
Matrix
temp(*this);
for (
int i = 0; i < numRows;
i++){
for
(int j = 0; j < numCols;
j++){
temp.elements[i][j]
*= d;
}
}
return
temp;
}
Matrix
operator * (const double d,
const Matrix& m)
{
Matrix
temp(m);
temp = temp *
d;
return
temp;
}
Matrix
Matrix::operator / (const double
d)
{
Matrix
temp(*this);
for(int
i=0; i< numRows;
i++){
for(int
j=0; j<numCols;
j++){
temp.elements[i][j]
/= d;
}
}
return
temp;
}
Matrix
operator + (double d, Matrix
&m)
{
Matrix
temp(m);
for(int
i=0; i< temp.numRows;
i++){
Page
580
CS201
Introduction to Programming
for(int
j=0; j<temp.numCols;
j++){
temp.elements[i][j]
*= d;
}
}
return
temp;
}
Matrix
operator  (double d, Matrix&
m)
{
Matrix
temp(m);
for(int
i=0; i< temp.numRows;
i++){
for(int
j=0; j<temp.numCols;
j++){
temp.elements[i][j]
= d  temp.elements[i][j];
}
}
return
temp;
}
ostream
& operator << ( ostream &
os, Matrix & m)
{
m.output();
return
os;
}
istream &
operator >> ( istream & is,
Matrix & m)
{
m.input(is);
return
is;
}
ofstream
& operator << ( ofstream &
os, Matrix & m)
{
m.output(os);
return
os;
}
ifstream &
operator >> ( ifstream & is,
Matrix & m)
{
m.input(is);
return
is;
}
int
main()
{
// declaring
two matrices
Matrix
m(4,5), n(5,4);
Page
581
CS201
Introduction to Programming
// getting
input from keyboard
cout
<< "Taking the input
for m(4,5) and n(5,4)
\n";
m.input();
n.input();
//
displaying m and taking its
transpose
cout
<< "Displaying the matrix
m(4,5) and n(5,4)\n";
m.output();
n.output();
cout
<< "Taking the transpose of
matrix m(4,5) \n";
m.transpose();
cout
<< "Displaying the matrix
m(5,4) and n(5,4)
\n";
m.output();
cout
<< "Adding matrices n into m
\n";
m = m +
n;
m.output();
cout
<< "Calling m + m + 4 \n";
m = m + m +
4;
m.output();
cout
<< "Calling m += n \n";
m +=
n;
m.output();
cout
<< "Calling m = m  n \n";
m = m 
n;
m.output();
cout
<< "Calling m = m  4 \n";
m = m 
4;
m.output();
cout
<< "Calling m = n \n";
m =
n;
m.output();
m.transpose();
Matrix
c;
cout
<< "Calling c = m * n \n";
Page
582
CS201
Introduction to Programming
c = m *
n;
c.output();
cout
<< "Calling c = c * 4.0
\n";
c = c *
4.0;
c.output();
cout
<< "Calling c = 4.0 * c
\n";
c = 4.0 *
c ;
c.output();
cout
<< "Testing stream extraction
\n";
// cin
>> c;
cout
<< "Testing stream insertion
\n";
// cout
<< c;
cout
<< "Writing into the
file d:\\junk.txt \n"
;
ofstream
fo("D:/junk.txt");
fo <<
c;
fo.close();
cout
<< "Reading from the file
d:\\junk.txt \n";
ifstream
fi("D:/junk.txt");
fi >>
c;
fi.close();
cout
<< c;
system("PAUSE");
return
0;
}
The
output of the program is:
Taking
the input for m(4,5)
and n(5,4)
Input
Matrix size: 4 rows by 5 columns
Please
enter 5 values separated by
spaces for row no.1:
1.0 2.0 3.0 4.0
5.0
Please
enter 5 values separated by
spaces for row no.2:
7.0 5.5 2.3 2.0
1.0
Please
enter 5 values separated by
spaces for row no.3:
3.3 2.2 1.1 4.4
5.5
Please
enter 5 values separated by
spaces for row no.4:
9.9 5.7 4.3 2.3
1.5
Input
Matrix size: 5 rows by 4 columns
Please
enter 4 values separated by
spaces for row no.1:
11.25 12.25 13.25
14.25
Please
enter 4 values separated by
spaces for row no.2:
25.25 50.50 75.75
25.50
Please
enter 4 values separated by
spaces for row no.3:
15.15 5.75 9.99
19.90
Page
583
CS201
Introduction to Programming
Please
enter 4 values separated by
spaces for row no.4:
25.50 75.75 10.25
23.40
Please
enter 4 values separated by
spaces for row no.5:
50.50 75.50 25.25
15.33
Displaying
the matrix m(4,5) and
n(5,4)
┌
┐
│
1.00
2.00
3.00
4.00
5.00│
│
7.00
5.50
2.30
2.00
1.00│
│
3.30
2.20
1.10
4.40
5.50│
│
9.90
5.70
4.30
2.30
1.50│
└
┘
┌
┐
│ 11.25
12.25 13.25
14.25│
│ 25.25
50.50 75.75
25.50│
│ 15.15
5.75
9.99 19.90 │
│ 25.50
75.75 10.25
23.40│
│ 50.50
75.50 25.25
15.33│
└
┘
Taking
the transpose of matrix
m(4,5)
Displaying
the matrix m(5,4) and
n(5,4)
┌
┐
│
1.00
7.00
3.30
9.90│
│
2.00
5.50
2.20
5.70│
│
3.00
2.30
1.10
4.30│
│
4.00
2.00
4.40
2.30│
│
5.00
1.00
5.50
1.50│
└
┘
Adding
matrices n into m
┌
┐
│ 12.25
19.25 16.55
24.15│
│ 27.25
56.00 77.95
31.20│
│ 18.15
8.05
11.09 24.20 │
│ 29.50
77.75 14.65
25.70│
│ 55.50
76.50 30.75
16.83│
└
┘
Calling m
+ m + 4
┌
┐
│ 28.50
42.50 37.10 52.30
│
│ 58.50
116.00 159.90
66.40│
│ 40.30
20.10 26.18 52.40
│
│ 63.00
159.50 33.30 55.40
│
│ 115.00
157.00 65.50
37.66│
└
┘
Calling m
+= n
┌
┐
│ 39.75
54.75 50.35 66.55
│
│ 83.75
166.50 235.65
91.90│
│ 55.45
25.85 36.17 72.30
│
Page
584
CS201
Introduction to Programming
│ 88.50
235.25 43.55 78.80
│
│ 165.50
232.50 90.75
52.99│
└
┘
Calling m
= m  n
┌
┐
│ 28.50
42.50 37.10 52.30
│
│ 58.50
116.00 159.90
66.40│
│ 40.30
20.10 26.18 52.40
│
│ 63.00
159.50 33.30 55.40
│
│ 115.00
157.00 65.50
37.66│
└
┘
Calling m
= m  4
┌
┐
│ 24.50
38.50 33.10 48.30
│
│ 54.50
112.00 155.90
62.40│
│ 36.30
16.10 22.18 48.40
│
│ 59.00
155.50 29.30 51.40
│
│ 111.00
153.00 61.50
33.66│
└
┘
Calling m
= n
┌
┐
│ 13.25
26.25 19.85 34.05
│
│ 29.25
61.50 80.15 36.90
│
│ 21.15
10.35 12.19 28.50
│
│ 33.50
79.75 19.05 28.00
│
│ 60.50
77.50 36.25 18.33
│
└
┘
Calling c
= m * n
┌
┐
│ 5117.55
8866.42 4473.54 3066.94 │
│ 7952.36
15379.14 7884.15 5202.50 │
│ 4748.18
8540.74 7566.73 3570.75 │
│ 3386.23
5949.35 4280.89 2929.51 │
└
┘
Calling c
= c * 4.0
┌
┐
│ 20470.19
35465.70 17894.15 12267.75 │
│ 31809.46
61516.55 31536.59 20810.01 │
│ 18992.71
34162.97 30266.91 14283.00 │
│ 13544.91
23797.41 17123.54 11718.05 │
└
┘
Calling c
= 4.0 * c
┌
┐
│ 81880.76
141862.80 71576.62
49071.00
│
│ 127237.84
246066.20 126146.34
83240.04
│
│ 75970.86
136651.88 121067.65
57132.02
│
Page
585
CS201
Introduction to Programming
│ 54179.64
95189.64 68494.16
46872.18
│
└
┘
Testing
stream extraction
Testing
stream insertion
Writing
into the file
d:\junk.txt
Reading
from the file
d:\junk.txt
┌
┐
│ 81880.76
0.81
0.62
0.00
│
│ 127237.84
0.20
0.35
0.04
│
│ 75970.86
0.88
0.66
0.02
│
│ 54179.65
0.65
0.16
0.18
│
└
┘
Press
any key to continue . .
.
Page
586
Table of Contents:

