Generikus mátrix osztály

// Matrix.h
#ifndef MATRIX_H
#define MATRIX_H

#include <exception>

// Megjegyzes: ez a megoldas egydimenzios egy tombot hasznal az osztalyon belul, de hivo fel fele
// ugy mutatja be mintha ketdimenzios lenne. Nyilvan nem ez az egyetlen udvozito megoldas, a
// feladat megoldhato ketdimenzios dinamikus tombbel is.
template <class T>
class Matrix {
 private:
  unsigned Rows, Columns;
  T *pData;

 public:
  Matrix(unsigned R = 0, unsigned C = 0);
  Matrix(const Matrix &M) { pData = 0; *this = M; }
  ~Matrix() { delete[] pData; }

  Matrix &operator=(const Matrix &M);
  Matrix operator+(const Matrix &M) const;
  T &operator()(unsigned R, unsigned C);
  const T &operator()(unsigned R, unsigned C) const;
};

template <class T>
Matrix<T>::Matrix(unsigned R, unsigned C) {
 Rows = R;
 Columns = C;
 pData = (Rows > 0 && Columns > 0) ? (new T[Rows * Columns]) : 0;
}

template <class T>
Matrix<T> &Matrix<T>::operator=(const Matrix<T> &M) {
 if (this == &M) {
  return *this;
 }

 delete[] pData;
 Rows = M.Rows;
 Columns = M.Columns;
 pData = (Rows > 0 && Columns > 0) ? (new T[Rows * Columns]) : 0;

 for (unsigned i = 0; i < Rows * Columns; i++) {
  pData[i] = M.pData[i];
 }

 return *this;
}

template <class T>
Matrix<T> Matrix<T>::operator+(const Matrix<T> &M) const {
 if (Rows != M.Rows && Columns != M.Columns) {
  throw std::exception("A ket matrix dimenzioi nem egyeznek, ezert nem adhatok ossze!");
 }

 Matrix RetVal = *this;

 for (unsigned i = 0; i < Rows * Columns; i++) {
  RetVal.pData[i] = RetVal.pData[i] + M.pData[i];
 }

 return RetVal;
}

template <class T>
T &Matrix<T>::operator()(unsigned R, unsigned C) {
 if (R >= Rows || C >= Columns) {
  throw std::exception("Hibas sor- vagy oszlopindex!");
 }

 return pData[R * Columns + C];
}

template <class T>
const T &Matrix<T>::operator()(unsigned R, unsigned C) const {
 if (R >= Rows || C >= Columns) {
  throw std::exception("Hibas sor- vagy oszlopindex!");
 }

 return pData[R * Columns + C];
}

#endif // MATRIX_H



// Main.cpp
#include "Matrix.h"
#include <iostream>
using namespace std;

int main(){
 Matrix<int> m1(2, 2);
 m1(0, 0) = 2;
 m1(0, 1) = 0;
 m1(1, 0) = 0;
 m1(1, 1) = 2;

 Matrix<int> m2 = m1 + m1;
 
 cout << m2(0, 0) << " " << m2(0, 1) << endl;
 cout << m2(1, 0) << " " << m2(1, 1) << endl;

 return 0;
}

// Kovetelmenyek a tarolt tipussal szemben (ha az nem beepitett tipus):
// - rendelkezik alapertelmezett konstruktorral
// - egymashoz lehet oket rendelni az = operatorral
// - ossze lehet belole adni ket peldanyt a + operatorral