Ciao a tutti. Sto cercando di creare una classe che rappresenti delle matrici (nel senso matematico del termine). Ho utilizzato i template e la classe std::array come contenitore.

Di seguito il codice che ho scritto. Sapreste dirmi com'é? Funzionale? Buono? Oppure fa schifo ed é meglio lasciar perdere. Mi piacerebbe creare una classe più o meno completa (operazioni di base) che io possa sempre riutilizzare nei miei programmi di fisica computazionale. L'operazione é però più facile a dirsi che a farsi...

codice:
#ifndef MATRIX_H
#define MATRIX_H

#include <array>
#include <initializer_list>
#include <cassert>

template <size_t row, size_t col>
class Matrix
{
public:
	Matrix();
	Matrix(const std::initializer_list<double>&);
	Matrix(const Matrix&);
	virtual ~Matrix();
	
	Matrix& operator=(const Matrix&);
	bool operator==(const Matrix&) const;
    bool operator!=(const Matrix&) const;
    Matrix& operator+=(const Matrix&);
    Matrix& operator-=(const Matrix&);
    Matrix operator+(const Matrix&) const;
    Matrix operator-(const Matrix&) const;
	double& operator()(int, int);
	const double& operator()(int, int) const;
	
	int get_row() const;
	int get_col() const;
	void set(double);
	
	
private:
	std::array< std::array<double,col>, row> matrix;
	size_t r;
	size_t c;
	
	void copy(const Matrix&);
};

#endif

template <size_t row, size_t col>
Matrix<row,col>::Matrix()
: r(row), c(col)
{
	set(0.);
}

template <size_t row, size_t col>
Matrix<row,col>::Matrix(const std::initializer_list<double>& l)
: matrix(l), r(row), c(col)
{}

template <size_t row, size_t col>
Matrix<row,col>::Matrix(const Matrix& m)
{
	copy(m);
}

template <size_t row, size_t col>
Matrix<row,col>::~Matrix()
{}

Matrix& Matrix<row,col>::operator=(const Matrix& m)
{
	if(this != &m)
	{
		copy(m);
	}
	
	return *this;
}

bool Matrix<row,col>::operator==(const Matrix& m) const
{
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			if(matrix[i][j] != m.matrix[i][j])
			{
				return false;
			}
		}
	}
	
	return true;
}

bool Matrix<row,col>::operator!=(const Matrix& m) const
{
	return !( (*this) == m);
}

Matrix& Matrix<row,col>::operator+=(const Matrix& m)
{
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			matrix[i][j] += m.matrix[i][j];
		}
	}
	
	return *this;
}

Matrix& Matrix<row,col>::operator-=(const Matrix&)
{
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			matrix[i][j] -= m.matrix[i][j];
		}
	}
	
	return *this;
}

Matrix operator+(const Matrix& m) const
{
	Matrix tmp<r,c>(*this);
	
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			tmp.matrix[i][j] += m.matrix[i][j];
		}
	}
	
	return std::move(tmp);
}

Matrix operator-(const Matrix& m) const
{
	Matrix tmp<row,col>(*this);
	
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			tmp.matrix[i][j] -= m.matrix[i][j];
		}
	}
	
	return std::move(tmp);
}

template <size_t row, size_t col>
double& Matrix<row,col>::operator()(int i, int j)
{
	assert(i > 0 && i <= r);
  	assert(j > 0 && j <= c);

	return matrix[i-1][j-1];
}

template <size_t row, size_t col>
const double& Matrix<row,col>::operator()(int i, int j) const
{
	assert(i > 0 && i <= r);
  	assert(j > 0 && j <= c);

	return matrix[i-1][j-1];
}

template <size_t row, size_t col>
int Matrix<row,col>::get_row() const
{
	return r;
}

template <size_t row, size_t col>
int Matrix<row,col>::get_col() const
{
	return c;
}

template <size_t row, size_t col>
void Matrix<row,col>::set(double val)
{
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			matrix[i][j] = val;
		}
	}
}

template <size_t row, size_t col>
void Matrix<row,col>::copy(const Matrix& m)
{
	// r = m.r; c = m.c ???
	for(int i(0); i < row; i++)
	{
		for(int j(0); j < col; j++)
		{
			matrix[i][j] = m.matrix[i][j];
		}
	}
}
Grazie a tutti per l'aiuto.