Question

NO VECTORS PLEASE

Start a simple Matrix template class

In this lab, you’ll be writing a template class to represent a matrix. Because it’s a template, your matrix class will be able to work with different types of underlying data.

Start by creating a new file matrix.hpp. Inside this file, start to write your matrix template class. Here’s a start for the class definition:

template <class T>
class Matrix {
private:
  int _rows;
  int _cols;
  T** data;
public:
  Matrix(int rows, int cols);
  ~Matrix();
  int rows();
  int cols();
  T& at(int row, int col);
};

Here, the constructor should allocate the data field so that it contains the specified number of rows and columns, and the destructor should free the memory allocated to the data field (in addition to anything else you need to do in the destructor). In addition to the constructor and destructor, you should write accessors to return the number of rows and the number of columns.

You should also write an at() method that returns a reference to the data element at a specified location. By returning a reference, you can use the at() method to set values in a matrix as well as access them. The at() method should throw an std::out_of_range exception if either the specified row or the specified column is outside the bounds of the matrix.

Remember, all of the methods for a template class need to be implemented directly in the header file itself.

Once you have your Matrix class looking good, create a new file application.cpp. In this file, write a small application to test your Matrix class. Create a few Matrix objects containing different data types, like int, float, and double. Fill those Matrix objects with values using loops and the at() method, and print out some values from the matrices to make sure they look like what you expect. Try to access some values outside the bounds of your matrices to make sure an exception is thrown.

Make sure to add and commit your files to your git repository and push them to GitHub.

Step 3: Implement an add() method to add two matrices

Add a new method add() to your Matrix template class to add two Matrix objects. The declaration of this method inside your class definition should look like this:

void add(const Matrix<T>& other);

Importantly, note that the Matrix argument to your add() method will also be of the same type T. The add() method should simply take the value at each location in other and add it to the value at the corresponding location of the Matrixobject represented by this, replacing the latter with the sum of the two values.

Make sure to augment your application to test your add() method, commit your changes to your git repository, and push them to GitHub when everything is working.

Step 4: Write a size_mismatch exception and throw it in add()

One major catch about adding two matrices is that they must have the same dimensions. Otherwise, it’s not possible to add them. Your Matrix class should not allow the user to pass an argument other to the add() method that has different dimensions than the Matrix object represented by this. To do this, you should create a new file size_mismatch.hpp and, in it, write a new exception class called size_mismatch. This class should be derived from the std::exception class. Remember, at a minimum, a new class that derives from std::exception must implement the following method:

virtual const char* what() const throw();

However, you may implement any additional methods that help you make an informative exception (e.g. a new parameterized constructor). You may also add new private data members if needed. You may place the implementations of the class methods for size_mismatch directly in the class definition in size_mismatch.hpp, or you may create a new file size_mismatch.cpp in which to place these implementations.

Once you have your size_mismatch class written, augment your Matrix class’s add() method to throw a size_mismatchwhenever the other argument has different dimensions than the Matrix object represented by this.

Answer 1

#pragma once

#include <vector>
#include <exception>
#include <iosfwd>

template <typename T>
class Matrix
{
    std::vector<std::vector<T>> matrix;
    size_t rowCount;
    size_t columnCount;
public:
    Matrix(size_t rowCount_, size_t columnCount_):
        matrix(rowCount_), 
        rowCount(rowCount_), 
        columnCount(columnCount_)
    {
        for (auto& row : matrix)
        {
            row.resize(columnCount);
            for (auto& cell : row)
            {
                cell = 0;
            }
        }
    }

    Matrix(size_t rowCount_, size_t columnCount_, const T& value) :
        matrix(rowCount_),
        rowCount(rowCount_),
        columnCount(columnCount_)
    {
        for (auto& row : matrix)
        {
            row.resize(columnCount, value);
        }
    }

    Matrix(const Matrix& other) = default;

    Matrix(Matrix&& other) :
        matrix(std::move(other.matrix))
    {
        rowCount = other.rowCount;
        columnCount = other.columnCount;
    }

    Matrix& operator=(const Matrix& other) = default;

    Matrix& operator=(Matrix&& other)
    {
        std::swap(matrix, other.matrix);
        rowCount = other.rowCount;
        columnCount = other.columnCount;
        return *this;
    }

    Matrix& operator*=(const T& rhs)
    {
        for (auto& row : matrix)
        {
            for (auto& cell : row)
            {
                cell *= rhs;
            }
        }
        return *this;
    }

    Matrix& operator*=(const Matrix& rhs)
    {
        if (columnCount != rhs.rowCount)
        {
            throw std::logic_error("column count of lhs and row count of rhs are not equal\n");
        }

        Matrix temp(rowCount, rhs.columnCount);

        for (size_t i = 0; i < temp.rowCount; i++)
        {
            for (size_t j = 0; j < temp.columnCount; j++)
            {
                for (size_t k = 0; k < columnCount; k++)
                {
                    temp[i][j] += matrix[i][k] * rhs[j][k];
                }
            }
        }
        std::swap(matrix, temp.matrix);

        return *this;
    }

    Matrix& operator+=(const Matrix& rhs)
    {
        if (rowCount != rhs.rowCount || columnCount != rhs.columnCount)
        {
            throw std::logic_error("either or both of row count and column count of lhs and rhs are not equal\n");
        }

        for (size_t i = 0; i < rowCount; i++)
        {
            for (size_t j = 0; j < columnCount; j++)
            {
                matrix[i][j] += rhs[i][j];
            }
        }

        return *this;
    }
    size_t rows()
    {
        return rowCount;
    }

    size_t columns()
    {
        return columnCount;
    }

    const size_t rows() const
    {
        return rowCount;
    }

    const size_t columns() const
    {
        return columnCount;
    }

    std::vector<T>& operator[](size_t row)
    {
        return matrix[row];
    }

    const std::vector<T>& operator[](size_t row) const
    {
        return matrix[row];
    }
};

template <typename T>
bool operator==(const Matrix<T>& lhs, const Matrix<T>& rhs)
{
    if (lhs.rows() != rhs.rows() || lhs.columns() != rhs.columns())
    {
        return false;
    }

    for (int i = 0; i < lhs.rows(); i++)
    {
        for (int j = 0; j < lhs.columns(); j++)
        {
            if (lhs[i][j] != rhs[i][j])
            {
                return false;
            }
        }
    }
    return true;
}

template <typename T>
bool operator!=(const Matrix<T>& lhs, const Matrix<T>& rhs)
{
    return !(lhs == rhs);
}

template <typename T>
Matrix<T> operator+(Matrix<T> lhs, const Matrix<T>& rhs)
{
    return lhs += rhs;
}

template <typename T>
Matrix<T> operator*(Matrix<T> lhs, const Matrix<T>& rhs)
{
    return lhs *= rhs;
}

template <typename T>
Matrix<T> operator*(Matrix<T> lhs, const T& rhs)
{
    return lhs *= rhs;
}

template <typename T>
Matrix<T> operator*(const T& lhs, Matrix<T> rhs)
{
    return rhs *= lhs;
}

template <typename T>
std::istream& operator >> (std::istream& is, Matrix<T>& matrix)
{
    for (size_t i = 0; i < matrix.rows(); i++)
    {
        for (size_t j = 0; j < matrix.columns(); j++)
        {
            is >> matrix[i][j];
        }
    }

    return is;
}

template <typename T>
std::ostream& operator<< (std::ostream& os, const Matrix<T>& matrix)
{
    for (size_t i = 0; i < matrix.rows(); i++)
    {
        for (size_t j = 0; j < matrix.columns(); j++)
        {
            os << matrix[i][j] << ' ';
        }
        os << "\n";
    }

    return os;
}