#include <iostream>
#include <iomanip>
#include <cstring>
#include <stdexcept>
#include <new>
#include <string>
#include <sstream>

template <typename T>
std::string PretvoriUString(T x){
	std::ostringstream s;
	s << x;
	return s.str();
}

template<typename TipEl>
class Matrica {
	int br_redova, br_kolona;
	TipEl** elementi;
	char ime_matrice;
	static TipEl **AlocirajMemoriju(int br_redova, int br_kolona);
 	static void DealocirajMemoriju(TipEl **elementi, int br_redova);
	void KopirajElemente(TipEl **elementi);
	void TestIndeksa(int red) const{
		if(red < 0 || red>br_redova)
			throw std::range_error("Pogresan indeks!");
	}
public:
	Matrica(int br_redova, int br_kolona, char ime= 0);
	Matrica(const Matrica &m);
	Matrica(Matrica &&m);
	~Matrica() { DealocirajMemoriju(elementi, br_redova); }
	Matrica &operator=(const Matrica &m);
	Matrica &operator=(Matrica &&m);
	TipEl *operator [](int red) const{
		TestIndeksa(red);
		return elementi[red];
	}
	TipEl &operator ()(int red, int kolona){
		if(red < 1 || kolona < 1 || red > br_redova || kolona > br_kolona) throw std::range_error("Neispravan indeks");
		return elementi[red-1][kolona-1];
	}

	operator std::string() const;

	friend std::ostream &operator<<(std::ostream &tok, const Matrica &m){
		int duzina_ispisa(std::cout.width());
		for(int i = 0; i < m.br_redova; i++) {
 			for(int j = 0; j < m.br_kolona; j++)
 				tok << std::setw(duzina_ispisa)  << m.elementi[i][j];
 			tok << std::endl;
	 	}
 		return tok;
	}

	template<typename Tip2>
	friend Matrica<Tip2> operator *(const Matrica<Tip2> &m1, const Matrica<Tip2> &m2);
	template<typename Tip2>
	friend Matrica<Tip2> operator +(const Matrica<Tip2> &m1, const Matrica<Tip2> &m2);
	template<typename Tip2>
	friend Matrica<Tip2> operator -(const Matrica<Tip2> &m1, const Matrica<Tip2> &m2);
	template<typename Tip2>
	friend Matrica<Tip2> &operator *=(Matrica<Tip2> &m1, const Matrica<Tip2> &m2);
	template<typename Tip2>
	friend Matrica<Tip2> &operator +=(Matrica<Tip2> &m1, const Matrica<Tip2> &m2);
	template<typename Tip2>
	friend Matrica<Tip2> &operator -=(Matrica<Tip2> &m1, const Matrica<Tip2> &m2);
};

template <typename TipEl>
Matrica<TipEl> :: operator std::string() const{
		std::string s, pomocni;
		s += "{";
		for(int i=0; i<br_redova; i++){
			s += "{";
			for(int j=0; j<br_kolona; j++){
				pomocni = PretvoriUString(elementi[i][j]);
				s += pomocni;
				if(j != br_kolona-1) s += ",";
			}
			if(i != br_redova-1) s += "},";
			else s += "}";
		}
		s += "}";
		return s;
	}

template <typename TipEl>
TipEl **Matrica<TipEl>::AlocirajMemoriju(int br_redova, int br_kolona) {
	TipEl **elementi(new TipEl*[br_redova]{});
	try{
		for(int i = 0; i < br_redova; i++) elementi[i] = new TipEl[br_kolona];
	}catch(...) {
		DealocirajMemoriju(elementi, br_redova);
		throw;
	}
	return elementi;
}

template <typename TipEl>
void Matrica<TipEl>::DealocirajMemoriju(TipEl **elementi, int br_redova) {
	for(int i = 0; i < br_redova; i++) delete[] elementi[i];
	delete[] elementi;
}

template<typename TipEl>
Matrica<TipEl>::Matrica(int br_redova, int br_kolona, char ime) : br_redova(br_redova), br_kolona(br_kolona), elementi(AlocirajMemoriju(br_redova, br_kolona)), ime_matrice(ime) {}

template<typename TipEl>
void Matrica<TipEl>::KopirajElemente(TipEl **elementi) {
	for(int i = 0; i < br_redova; i++)
		for(int j = 0; j < br_kolona; j++)
			Matrica::elementi[i][j] = elementi[i][j];
}

template<typename TipEl>
Matrica<TipEl>::Matrica(const Matrica<TipEl> &m) : br_redova(m.br_redova),  br_kolona(m.br_kolona), elementi(AlocirajMemoriju(m.br_redova, m.br_kolona)), ime_matrice(m.ime_matrice){
	KopirajElemente(m.elementi);
}

template< typename TipEl>
Matrica<TipEl>::Matrica(Matrica<TipEl> &&m) : br_redova(m.br_redova), br_kolona(m.br_kolona), elementi(m.elementi), ime_matrice(m.ime_matrice) {
	m.br_redova = 0; m.elementi = nullptr;
}

template <typename TipEl>
Matrica<TipEl> &Matrica<TipEl>::operator =(const Matrica<TipEl> &m) {
 	if(br_redova < m.br_redova || br_kolona < m.br_kolona) {
 		TipEl **novi_prostor(AlocirajMemoriju(m.br_redova, m.br_kolona));
 		DealocirajMemoriju(elementi, br_redova);
 		elementi = novi_prostor;
 	}
 	else if(br_redova > m.br_redova)
 		for(int i = m.br_redova; i < br_redova; i++) delete elementi[i];
 	br_redova = m.br_redova; br_kolona = m.br_kolona;
 	ime_matrice = m.ime_matrice;
 	KopirajElemente(m.elementi);
 	return *this;
 }
template <typename TipEl>
Matrica<TipEl> &Matrica<TipEl>::operator =(Matrica<TipEl> &&m) {
 	std::swap(br_redova, m.br_redova); std::swap(br_kolona, m.br_kolona);
 	std::swap(ime_matrice, m.ime_matrice); std::swap(elementi, m.elementi);
 	return *this;
}

template <typename TipEl>
Matrica<TipEl> operator +(const Matrica<TipEl> &m1,const Matrica<TipEl> &m2) {
 	if(m1.br_redova != m2.br_redova || m1.br_kolona != m2.br_kolona)
 		throw std::domain_error("Matrice nemaju jednake dimenzije!");
 	Matrica<TipEl> m3(m1.br_redova, m1.br_kolona);
 	for(int i = 0; i < m1.br_redova; i++)
 		for(int j = 0; j < m1.br_kolona; j++)
 			m3.elementi[i][j] = m1.elementi[i][j] + m2.elementi[i][j];
 	return m3;
}

template <typename TipEl>
Matrica<TipEl> &operator +=(Matrica<TipEl> &m1,const Matrica<TipEl> &m2) {
 	if(m1.br_redova != m2.br_redova || m1.br_kolona != m2.br_kolona)
 		throw std::domain_error("Matrice nemaju jednake dimenzije!");
 	return m1 = m1+m2;
}

template <typename TipEl>
Matrica<TipEl> operator -(const Matrica<TipEl> &m1,const Matrica<TipEl> &m2) {
 	if(m1.br_redova != m2.br_redova || m1.br_kolona != m2.br_kolona)
 		throw std::domain_error("Matrice nemaju jednake dimenzije!");
 	Matrica<TipEl> m3(m1.br_redova, m1.br_kolona);
 	for(int i = 0; i < m1.br_redova; i++)
 		for(int j = 0; j < m1.br_kolona; j++)
 			m3.elementi[i][j] = m1.elementi[i][j] - m2.elementi[i][j];
 	return m3;
}

template <typename TipEl>
Matrica<TipEl> &operator -=(Matrica<TipEl> &m1,const Matrica<TipEl> &m2) {
 	if(m1.br_redova != m2.br_redova || m1.br_kolona != m2.br_kolona)
 		throw std::domain_error("Matrice nemaju jednake dimenzije!");
 	return m1 = m1-m2;
}

template <typename TipEl>
Matrica<TipEl> operator *(const Matrica<TipEl> &m1,const Matrica<TipEl> &m2) {
 	if(m1.br_kolona != m2.br_redova)
 		throw std::domain_error("Matrice nisu saglasne za mnozenje");
 	Matrica<TipEl> m3(m1.br_redova, m2.br_kolona);
 	for(int i=0; i<m3.br_redova; i++){
 		for(int j=0; j<m3.br_kolona; j++){
 			m3[i][j] = 0;
 		}
 	}
 	TipEl proizvod(1);
 	int i(0), j(0), k(0);
 	for(i = 0; i < m1.br_redova; i++){
 		for( j=0; j < m2.br_kolona; j++){
 			proizvod = 0;
 			for( k=0; k<m1.br_kolona; k++){
 				proizvod += (m1[i][k] * m2[k][j]);
 			}
 			m3[i][j] = proizvod;
 		}
 	}
 	return m3;
}

template <typename TipEl>
Matrica<TipEl> &operator *=(Matrica<TipEl> &m1,const Matrica<TipEl> &m2) {
 	if(m1.br_kolona != m2.br_redova)
 		throw std::domain_error("Matrice nisu saglasne za mnozenje");
 	return m1 = m1*m2;
}


int main ()
{	 try {
Matrica<int> a(2, 3, 'a');
a(0,0) = 1; a(0,1) = 2; a(0,2) = 3;
a(1,0) = 4; a(1,1) = 5; a(1,2) = 7;
Matrica<int> b(2, 3, 'b');
b(0,0) = 1; b(0,1) = 2; b(0,2) = 3;
b(1,0) = 4; b(1,1) = 5; b(1,2) = 6;
}
  catch(std::bad_alloc) {
    std::cout << "Nema dovoljno memorije!\n";
  }
    catch(std::domain_error e) {
    std::cout << e.what();
  }
    catch(std::range_error e) {
    std::cout << e.what();
  }
/*
	Matrica<double> a(m, n, 'A'), b(m, n, 'B');
std::cout << "Unesi matricu A:\n";
std::cin >> a;
std::cout << "Unesi matricu B:\n";
std::cin >> b;
std::cout << "Zbir ove dvije matrice je:\n";
std::cout << std::setw(7) << a + b;
*/
	return 0;
}