cs11_c++_lab3

Matrix.hh

 class Matrix
 {
     int row;
     int col;
     int *p;
     void copy(const Matrix &m);
     void clearup();
 public:

     Matrix();
     Matrix(int x,int y);
     ~Matrix();

     Matrix(const Matrix &m);

     const int getrows() const;
     const int getcols() const;

     void setelem(int x,int y,int elem);

     const int getelem(int x,int y) const;

     Matrix & operator=(const Matrix &m);
     Matrix & operator+=(const Matrix &m);
     Matrix & operator-=(const Matrix &m);
     Matrix & operator*=(const Matrix &m);

     const Matrix operator+(const Matrix &m) const;
     const Matrix operator-(const Matrix &m) const;
     const Matrix operator*(const Matrix &m) const;

     bool operator==(const Matrix &m) const;
     bool operator!=(const Matrix &m) const;

 };

Matrix.cpp

 #include "Matrix.hh"
 #include <cassert>
 #include <iostream>

 using namespace std;

 Matrix::Matrix()
 {
     row=;
     col=;
     p=;
 }

 Matrix::Matrix(int x,int y)
 {
     assert(x>=);
     assert(y>=);
     row=x;
     col=y;
     p=new int[row*col];
     for(int i=;i<row*col;i++)
         p[i]=;
 }

 void Matrix::copy(const Matrix &m)
 {
 //    row = m.row;
 //    col = m.row;
     p = new int[row * col];
     for(int i = ;i < row * col;i++)
         p[i]=m.p[i];
 }

 void Matrix::clearup()
 {
     delete[] p;
 }

 Matrix::Matrix(const Matrix &m)
 {
     row = m.row;
     col = m.col;
     (*this).copy(m);
 }

 Matrix::~Matrix()
 {
     (*this).clearup();
 }

 const int Matrix::getrows() const
 {
     return row;
 }

 const int Matrix::getcols() const
 {
     return col;
 }

 const int Matrix::getelem(int x,int y) const
 {
     assert(x>=);
     assert(y>=);
     return p[x*col+y];
 }

 void Matrix::setelem(int x,int y,int elem)
 {
     assert(x>=);
     assert(y>=);
     p[x*col+y]=elem;
 }

 Matrix & Matrix:: operator=(const Matrix &m)
 {
     if(this!=&m)
     {
         clearup();
         row = m.row;
         col = m.col;
         (*this).copy(m);
     }
     return *this;
 }

 Matrix & Matrix:: operator+=(const Matrix &m)
 {
     assert(row==m.row);
     assert(col==m.col);
     for(int i=;i<row*col;i++)
         p[i]+=m.p[i];
     return *this;
 }

 Matrix & Matrix:: operator-=(const Matrix &m)
 {
     assert(row==m.row);
     assert(col==m.col);
     for(int i=;i<row*col;i++)
         p[i]-=m.p[i];
     return *this;
 }

 Matrix & Matrix:: operator*=(const Matrix &m)
 {
 //    assert(col==m.row);
     int *pp = new int[row * m.col];
     int sum = ;
     for(int i=;i<row;i++)
     {
         for(int j=;j<m.col;j++)
         {
             for(int k=;k<col;k++)
             {
                 sum+=p[i * row + k] * m.p[k * m.row + j];
             }
             pp[i * m.col + j]=sum;
             sum = ;
         }
     }

     delete[] p;
     p = pp;
     col = m.col;
     return *this;
 }

 const Matrix Matrix:: operator+(const Matrix &m) const
 {
     assert(row == m.row);
     assert(col == m.col);

     Matrix other;
     other = *this;
     other += m;
     return other;
 }

 const Matrix Matrix:: operator-(const Matrix &m) const
 {
     assert(row == m.row);
     assert(col == m.col);

     Matrix other;
     other = *this;
     other -= m;
     return other;
 }

 const Matrix Matrix:: operator*(const Matrix &m) const
 {
     assert(col==m.row);
     Matrix other;
     other = *this;
     other *= m;
     return other;;
 }

 bool Matrix:: operator==(const Matrix &m) const
 {
     bool b = true;
 //    assert(row == m.row);
 //    assert(col == m.col);
     if(row != m.row || col != m.col)
          return false;
     for(int i = ; i < row * col; i++)
     {
         if(p[i] != m.p[i])
         {
             b = false;
             return b;
         }
     }
     return b;
 }

 bool Matrix:: operator!=(const Matrix &m) const
 {
     return !((*this)==m);
 }

 /*
 void Matrix:: add(Matrix &m)
 {
     assert(    (row==m.row) || (col==m.col) );
     for(int i=0;i<row*col;i++)
     p[i]+=m.p[i];
 }

 void Matrix::subtract(Matrix &m)
 {
     assert( (row==m.row) || (col==m.col) );
     for(int i=0;i<row*col;i++)
     p[i]-=m.p[i];
 }

 bool Matrix::equals(Matrix &m)
 {
     bool b=true;
     if( (row!=m.row) || (col!=m.col) )return false;
     for(int i=0;i<row*col;i++)
         if(p[i]!=m.p[i])
         {    b=false;return b;}
     return b;
 }
 */