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=0;
    col=0;
    p=0;
}

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

void Matrix::copy(const Matrix &m)
{
//    row = m.row;
//    col = m.row;
    p = new int[row * col];
    for(int i = 0;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>=0);
    assert(y>=0);
    return p[x*col+y];
}

void Matrix::setelem(int x,int y,int elem)
{
    assert(x>=0);
    assert(y>=0);
    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=0;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=0;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 = 0;
    for(int i=0;i<row;i++)
    {
        for(int j=0;j<m.col;j++)
        {
            for(int k=0;k<col;k++)
            {
                sum+=p[i * row + k] * m.p[k * m.row + j];
            }
            pp[i * m.col + j]=sum;
            sum = 0;
        }
    }
    
    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 = 0; 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;
}
*/