How can write a C plus plus programming on matrix addition only?

Answer 1

#include<iostream>

#include<array>

template<typename T, const size_t c>

class Matrix1D

{

public:

using data_type = std::array<T, c>;

using iterator = typename data_type::iterator;

using const_iterator = typename data_type::const_iterator;

private:

data_type m_data;

public:

~Matrix1D () = default;

Matrix1D () = default;

Matrix1D (const Matrix1D&) = default;

Matrix1D& operator= (const Matrix1D&) = default;

Matrix1D (Matrix1D&& source): m_data (std::move (source.m_data)) {}

Matrix1D& operator= (Matrix1D&& source) { m_data = std::move (source.m_data); return *this; }

Matrix1D& operator+= (const Matrix1D&);

iterator begin() { return m_data.begin(); }

iterator end() { return m_data.end(); }

const_iterator begin() const { return m_data.begin(); }

const_iterator end() const { return m_data.end(); }

};

template<typename T, const size_t c>

Matrix1D<T, c>& Matrix1D<T, c>::operator+= (const Matrix1D<T, c>& rhs)

{

iterator ita;

const_iterator itb;

for (ita=begin(), itb=rhs.begin(); ita!=end(); ++ita, ++itb)

*ita += *itb;

return *this;

}

template<typename T, const size_t c>

std::ostream& operator<< (std::ostream& os, const Matrix1D<T, c>& m)

{

for (Matrix1D<T, c>::const_iterator it=m.begin(); it!=m.end(); ++it)

os << *it << '\t';

return os;

}

template<typename T, const size_t r, const size_t c>

class Matrix2D

{

public:

using data_type = std::array<Matrix1D<T, c>, r>;

using iterator = typename data_type::iterator;

using const_iterator = typename data_type::const_iterator;

private:

data_type m_data;

public:

~Matrix2D () = default;

Matrix2D () = default;

Matrix2D (const Matrix2D&) = default;

Matrix2D& operator= (const Matrix2D&) = default;

Matrix2D (Matrix2D&& source): m_data (std::move (source.m_data)) {}

Matrix2D& operator= (Matrix2D&& source) { m_data = std::move (source.m_data); return *this; }

Matrix2D& operator+= (const Matrix2D&);

Matrix2D operator+ (const Matrix2D&);

iterator begin() { return m_data.begin(); }

iterator end() { return m_data.end(); }

const_iterator begin() const { return m_data.begin(); }

const_iterator end() const { return m_data.end(); }

};

template<typename T, const size_t r, const size_t c>

Matrix2D<T, r, c>& Matrix2D<T, r, c>::operator+= (

const Matrix2D<T, r, c>& rhs)

{

iterator ita;

const_iterator itb;

for (ita=begin(), itb=rhs.begin(); ita!=end(); ++ita, ++itb)

*ita += *itb;

return *this;

}

template<typename T, const size_t r, const size_t c>

Matrix2D<T, r, c> Matrix2D<T, r, c>::operator+ (const Matrix2D<T, r, c>& rhs)

{

Matrix2D<T, r, c> result (*this);

result += rhs;

return result;

}

template<typename T, const size_t r, const size_t c>

std::ostream& operator<< (std::ostream& os, const Matrix2D<T, r, c>& m)

{

for (Matrix2D<T, r, c>::const_iterator it=m.begin(); it!=m.end(); ++it)

os << *it << '\n';

return os;

}

int main()

{

const size_t rows = 2, cols = 3;

Matrix2D<int, rows, cols> A, B;

Matrix2D<int, rows, cols>::iterator it;

Matrix1D<int, cols>::iterator in;

int value = 1;

for (it=A.begin(); it!=A.end(); ++it)

{

for (in=(*it).begin(); in!=(*it).end(); ++in)

(*in) = value++;

}

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

for (it=B.begin(); it!=B.end(); ++it)

{

for (in=(*it).begin(); in!=(*it).end(); ++in)

(*in) = ++value;

}

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

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

}