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.

Question

Want to see more full solutions like this?

Answer 1

Textbook Question

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.

Expert Solution & Answer

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Want to see more full solutions like this?

Subscribe now to access step-by-step solutions to millions of textbook problems written by subject matter experts!

Students have asked these similar questions

Please no AI! Or if you do use AI, Check the work please! Thank you!

(Dynamic Programming.) Recall the problem presented in Assign- ment 3 where given a list L of n ordered integers you're tasked with removing m of them such that the distance between the closest two remaining integers is maxi- mized. See Assignment 1 for further clarification and examples. As it turns out there is no (known) greedy algorithm to solve this problem. However, there is a dynamic programming solution. Devise a dynamic programming solution which determines the maximum distance between the closest two points after removing m numbers. Note, it doesn't need to return the resulting list itself. Hint 1: Your sub-problems should be of the form S(i, j), where S(i, j) returns the maximum distance of the closest two numbers when only considering removing j of the first i numbers in L. As an example if L [3, 4, 6, 8, 9, 12, 13, 15], then S(4, 1) = 2, since the closest two values of L' = [3,4,6,8] are 6 and 8 after removing 4 (note, 8-6 = = 2). = Hint 2: For the sub-problem S(i, j),…

(Dynamic Programming.) A group of friends is visiting a number of attractions located along a highway, starting at kilometre 0, placed at distances ɑ1 < A2 < ···

Answer 2

Textbook Question

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.

Expert Solution & Answer

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Want to see more full solutions like this?

Subscribe now to access step-by-step solutions to millions of textbook problems written by subject matter experts!

Answer 3

Textbook Question

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.

Expert Solution & Answer

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Want to see more full solutions like this?

Subscribe now to access step-by-step solutions to millions of textbook problems written by subject matter experts!

Answer 4

Textbook Question

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.

Expert Solution & Answer

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Want to see more full solutions like this?

Subscribe now to access step-by-step solutions to millions of textbook problems written by subject matter experts!

Answer 5

Textbook Question

Answer 6

Textbook Question

Answer 7

Expert Solution & Answer

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Answer 8

Expert Solution & Answer

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Answer 9

Expert Solution & Answer

Answer 10

Expert Solution & Answer

Answer 11

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.

Answer 12

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:

ABSOLUTE C++ -TEXT, Chapter 10, Problem 1PP

Answer 13

Ch. 10 - Reread the code in Display 10.9. Then, write a...

Concept explainers

Videos

Explanation of Solution

Want to see more full solutions like this?

Chapter 10 Solutions

Additional Engineering Textbook Solutions