Question

C++ CODE:

The matrix class consists of two files: matrix.h and matrix.cpp.

The class has the following definition:
matrix

-size:int

-mat:int**

----------------

+matrix(file:string)

+~matrix()

+operator

+(add:matrix*):matrix &

+operator-(sub:matrix*):matrix &

+friend operator<<(out:ostream &, t:const matrix&):ostream &

+displayRow(r:int):void

The class variables are as follows:

• size: the number of rows and columns in a square matrix

• mat: the integer matrix that contains the numeric matrix itself. The methods have the following behaviour: 2

• matrix(file:string): The default constructor. It receives the name of a file that it must then read to construct a matrix. The first line of the file contains the size of the matrix. The remainder of the file contains the matrix, in a row/column format. Each line will have a number of elements with no delimiters. Each value will be between 0 and 9.

• matrix(): The destructor for the class. It deallocates the memory of the class. It will also print out the following message with a new line at the end: matrix sum: X where X is the sum of all of the elements in the matrix.

• operator+(add:matrix*): An overload of the + operator. It will be used in conjunction with other matrices in the following way: A=A+B A 2,3 4,5 B 1,2 3,4 A=A+B 3,5 7,9 where A and B are both matrices. If the two matrices are of different sizes, then nothing happens and A should remain unchanged. If the matrices are same size, then there should be an element-wise addition and the result should be stored in A. This operation should be chainable, so the operator can be used in conjunction with others or itself.

• operator-(sub:matrix*): An overload of the - operator. It will be used in conjunction with other matrices in the following way: A=A-B A 2,3 4,5 B 1,2 3,4 3 A=A-B 1,1 1,1 where A and B are both matrices. If the two matrices are of different sizes, then nothing happens and A should remain unchanged. If the matrices are same size, then there should be an element-wise subtraction and the result should be stored in A. This operation should be chainable, so the operator can be used in conjunction with others or itself.

• friend operator<<(out:ostream &, t:const matrix&): This overload of the << operator should display the entire matrix as is in the following format: 1,2,3 4,5,6 7,8,9 From each row, each element should be displayed with comma delimiters and a new line at the end.

• displayRow(r:int): This function receives a row (indexed from 0), and displays it in the following format: 1,2,3 From the appropriate row, each element should be displayed with comma delimiters and a new line at the end.

Your submission must contain matrix.h, matrix.cpp,main.cpp,mat.txt,mat2.txt . You will only need the iostream,sstream and fstream libraries for this

Answer 1

Code:

#include <iostream>
#include <sstream>
#include <fstream>

using namespace std;

//matrix.h
class Matrix
{
public:
   Matrix();
   Matrix(string file);
   ~Matrix();
   Matrix& operator + (const Matrix& add);
   Matrix& operator - (const Matrix& add);
   friend ostream& operator << (ostream& out, const Matrix& mat);
   void displayRow(int row);
private:
   int size;
   int** mat;
};

//matrix.cpp
Matrix::Matrix()
{
   size = 0;
   mat = nullptr;
}

Matrix::Matrix(string file)
{
   ifstream fin;
   fin.open(file);

   if (!fin.is_open())
       return;

   fin >> size;

   mat = new int*[size];

   for (size_t i = 0; i < size; i++)
   {
       mat[i] = new int[size];
   }

   string in;
   int row = 0, column = 0, count = 0;

   //reading the new line
   char ch;
   fin.get(ch);

   while (std::getline(fin, in))
   {
       stringstream ss(in);
       int num;
       while (ss >> num)
       {
           mat[row][column] = num;
           ++column;
       }
       column = 0;
       ++row;
   }

}

Matrix::~Matrix()
{
   for (size_t i = 0; i < size; i++)
   {
       delete[] mat[i];
   }

   delete[] mat;
   size = 0;
}

Matrix & Matrix::operator+(const Matrix& add)
{
   if (this->size == add.size)
   {
       for (size_t i = 0; i < size; i++)
       {
           for (size_t j = 0; j < size; j++)
           {
               this->mat[i][j] += add.mat[i][j];
           }
       }
   }

   return *this;
}

Matrix & Matrix::operator-(const Matrix& sub)
{
   if (this->size == sub.size)
   {
       for (size_t i = 0; i < size; i++)
       {
           for (size_t j = 0; j < size; j++)
           {
               this->mat[i][j] -= sub.mat[i][j];
           }
       }
   }
  
   return *this;
}

void Matrix::displayRow(int row)
{
   for (size_t i = 0; i < size; i++)
   {
       cout<< this->mat[row][i];
       if (i != (size - 1))
           cout << ",";
   }
   cout << "\n";
}

ostream & operator<<(ostream & out, const Matrix & mat)
{
   for (size_t i = 0; i < mat.size; i++)
   {
       for (size_t j = 0; j < mat.size; j++)
       {
           out << mat.mat[i][j];
           if (j != (mat.size - 1))
               out << ",";
       }
       cout << "\n";
   }
   cout << "\n";

   return out;
}

//main.cpp
int main()
{

Matrix m1("m1.txt");
   Matrix m2("m2.txt");

   Matrix m3, m4;

   m3 = m1 + m2;

   cout << m3;

   Matrix m5("m1.txt");

   m4 = m5 - m2;

   cout << m4;

   m2.displayRow(1);

   return 0;

}

Output:

m1.txt

m2.txt