Scusate. Nel codice precedente c'erano parecchi errori (avevo compilato un'altro programma e quindi ho creduto che fosse tutto ok). Questo é il codice corretto:
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()
{}

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


template <size_t row, size_t col>
bool Matrix<row,col>::operator==(const Matrix<row,col>& 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;
}


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


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


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


template <size_t row, size_t col>
Matrix<row,col> Matrix<row,col>::operator+(const Matrix<row,col>& m) const
{
	Matrix<row,col> tmp(*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>
Matrix<row,col> Matrix<row,col>::operator-(const Matrix<row,col>& m) const
{
	Matrix<row,col> tmp(*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];
		}
	}
}