Write c plus plus program to find product of matrices?

Answer 1

#include<iostream>

#include<iomanip>

#include<vector>

class matrix

{

private:

// a vector of vectors

std::vector< std::vector< int >> m_vect;

public:

// default constructor

matrix(unsigned rows, unsigned columns)

{

// rows and columns must be non-zero

if (!rows !columns)

{

throw;

}

m_vect.resize (rows);

for (unsigned row=0; row<rows; ++row)

{

m_vect[row].resize (columns);

for (unsigned column=0; column<columns; ++column)

{

m_vect[row][column] = 0;

}

}

}

// copy constructor

matrix(const matrix& copy)

{

m_vect.resize (copy.rows());

for (unsigned row=0; row<copy.rows(); ++row)

{

m_vect[row] = copy.m_vect[row];

}

}

// assignment operator (uses copy/swap paradigm)

matrix operator= (const matrix copy)

{

// note that copy was passed by value and was therefore copy-constructed

// so no need to test for self-references (which should be rare anyway)

m_vect.clear();

m_vect.resize (copy.rows());

for (unsigned row=0; row<copy.m_vect.size(); ++row)

m_vect[row] = copy.m_vect[row];

}

// allows vector to be used just as you would a 2D array (const and non-const versions)

const std::vector< int >& operator[] (unsigned row) const { return m_vect[row]; }

std::vector< int >& operator[] (unsigned row) { return m_vect[row]; }

// product operator overload

matrix operator* (const matrix& rhs) const;

// read-only accessors to return dimensions

const unsigned rows() const { return m_vect.size(); }

const unsigned columns() const { return m_vect[0].size(); }

};

// implementation of product operator overload

matrix matrix::operator* (const matrix& rhs) const

{

// ensure columns and rows match

if (columns() != rhs.rows())

{

throw;

}

// instantiate matrix of required size

matrix product (rows(), rhs.columns());

// calculate elements using dot product

for (unsigned x=0; x<product.rows(); ++x)

{

for (unsigned y=0; y<product.columns(); ++y)

{

for (unsigned z=0; z<columns(); ++z)

{

product[x][y] += (*this)[x][z] * rhs[z][y];

}

}

}

return product;

}

// output stream insertion operator overload

std::ostream& operator<< (std::ostream& os, matrix& mx)

{

for (unsigned row=0; row<mx.rows(); ++row)

{

for (unsigned column=0; column<mx.columns(); ++column)

{

os << std::setw (10) << mx[row][column];

}

os << std::endl;

}

return os;

}

int main()

{

matrix A(2,3);

matrix B(3,4);

int value=0, row, column;

// initialise matrix A (incremental values)

for (row=0; row<A.rows(); ++row)

{

for (column=0; column<A.columns(); ++column)

{

A[row][column] = ++value;

}

}

std::cout << "Matrix A:\n\n" << A << std::endl;

// initialise matrix B (incremental values)

for (row=0; row<B.rows(); ++row)

{

for (column=0; column<B.columns(); ++column)

{

B[row][column] = ++value;

}

}

std::cout << "Matrix B:\n\n" << B << std::endl;

// calculate product of matrices

matrix product = A * B;

std::cout << "Product (A x B):\n\n" << product << std::endl;

}