Chapter 10, Problem 1PP

Reread the code in Display 10.9. Then, write a class TwoD that implements the two-dimensional dynamic array of doubles using ideas from this display in its constructors. You should have a private member of type pointer to double to point to the dynamic array, and two int (or unsigned int) values that are MaxRows and MaxColS.

You should supply a default constructor for which you are to choose a default maximum row and column sizes and a parameterized constructor that allows the programmer to set maximum row and column sizes.

Further, you should provide a void member function that allows setting a particular row and column entry and a member function that returns a particular row and column entry as a value of type double.

Remark: It is difficult or impossible (depending on the details) to overload ( ) so it works as you would like for two-dimensional arrays. So simply use accessor and mutator functions using ordinary function notation.

Overload the + operator as a friend function to add two two-dimensional arrays. This function should return the TwoD object whose i^th row, jth column element is the sum of the i^th row, j^th column element of the left-hand operand TWOD object and the i^th row, j^th column element of the right-hand operand TwoD object.

Provide a copy constructor, an overloaded operator z, and a destructor.

Declare class member functions that do not change the data as const members.

Program Plan Intro

Program Plan:

• Define class named as TwoD and declare the variables for rows and columns.
• Declare a variable of pointer to double to point to the dynamic array.
• Define the default constructor and parameterized constructor to initialise rows and columns.
• Define the copy constructor that copies the values of one object array to another object array.
• Define operator + function declared as friend that add two dimensional arrays and return the sum.
• Use the setValue () function to set the values in the matrices m1 and m2 of double type.
• Finally write the main function to test the class TwoD.

Program Description:The purpose of the program is to set the values of two matrices of double type and add them to print the third matrix using the class TwoD and its constructors.

Explanation of Solution

Program:

//header files
#include <iostream>
usingnamespacestd;
//Create Class TwoD
classTwoD
{
//Private Data members
private:
intMaxRows;
intMaxCols;
//Declare array
double&Twoarr;
//Access Specifier
public:
//Create Default Constructor
TwoD()
{
//chooses default rows and columns
MaxRows=10;
MaxCols=10;
Twoarr=newdouble*[MaxRows];
for(int it =0; it <MaxRows;++it)
{
Twoarr[it]=newdouble[MaxCols];
}
}
//Create parameterised Constructor for setting the rows and columns
TwoD(int rows,int cols)
{
//chooses Default rows and columns
MaxRows= rows;
MaxCols= cols;
Twoarr=newdouble*[MaxRows];
for(int it =0; it <MaxRows;++it)
{
Twoarr[it]=newdouble[MaxCols];
}
}
//included the copy constructor
TwoD(constTwoD&matrix)
{
//rows and columns assigned to the constructor object
MaxRows=matrix.MaxRows;
MaxCols=matrix.MaxCols;
Twoarr=newdouble*[MaxRows];
for(int it =0; it <MaxRows;++it)
{
Twoarr[it]=newdouble[MaxCols];
for(intjt=0;jt<MaxCols;++jt)
{
Twoarr[it][jt]=matrix.Twoarr[it][jt];
}
}
}
//Destructor
~TwoD()
{
for(int it =0; it <MaxRows;++it)
{
delete[]Twoarr[it];
}
deleteTwoarr;
}

//member function for setting the values
voidsetValue(int row,int col,doubleval)
{
Twoarr[row][col]=val;
}
//Friend function which overloads the "+" Operator
friendTwoDoperator+(TwoD&m1,TwoD&m2)
{
TwoD*m3 =newTwoD(m1.MaxRows, m1.MaxCols);
for(int it =0; it < m3->MaxRows;++it)
{
for(intjt=0;jt< m3->MaxCols;++jt)
{
//Performs addition
                m3->Twoarr[it][jt]= m1.Twoarr[it][jt]+ m2.Twoarr[it][jt];
}
}
return*m3;
}
//Void function to print the values
void print()
{
for(int it =0; it <MaxRows;++it)
{
for(intjt=0;jt<MaxCols;++jt)
{
cout<<Twoarr[it][jt]<<"";
}
cout<<endl;
}
}
};

intmain()
{
//declare variables
intmaxRows;
intmaxColumns;
//Getting inputs from the user
cout<<"Enter row Dimensions of the array:"<<endl;
cin>>maxRows;
cout<<"Enter Column Dimensions of the array:"<<endl;
cin>>maxColumns;
cout<<"&********************************"**lt;<endl;
cout<<"Echoing the two-dimensional Array"<<endl;
cout<<"&********************************"**lt;<endl;
//passing parameters to the class objects
TwoDm1(maxRows,maxColumns);
TwoDm2(maxRows,maxColumns);

for(int it =0; it <maxRows;++it)
{
for(intjt=0;jt<maxColumns;++jt)
{
m1.setValue(it,jt,0.2*(it +jt));
m2.setValue(it,jt,0.3*(it -jt));
}
}
//printing the results
cout<<"&***********"**lt;<endl;
cout<<"Matrix 1 "<<endl;
cout<<"&***********"**lt;<endl;
m1.print();
cout<<"&***********"**lt;<endl;
cout<<"Matrix 2"<<endl;
cout<<"&***********"**lt;<endl;
m2.print();
//performs the addition operation
TwoD m3 = m1 + m2;
cout<<"&***********"**lt;<endl;
cout<<"Addition "<<endl;
cout<<"&***********"**lt;<endl;
m3.print();
return0;
}

Explanation:

First, TwoD class is defined along with all the required variables and constructors. Then, from the main ()function, the instances of the class is called, the rows of the array and the column of the array are entered by the user.

The two dimensional array is echoed randomly. Two matrices of given order are generated. The sum of these two matrices are obtained and displayed on the output screen.

Output Screenshot: