При возврате объекта из функции пишет, что для объекта не определен констуктор копирования

#include <iostream>
#include "matrix.hpp"
 
using namespace std;
 
template < class T >
std::ostream& operator<<(std::ostream& out, const Matrix<T>& matrix);
 
int main()
{
   Matrix<int> matrix(10, 10);
   Matrix<int> matrix2(matrix);
 
   matrix.at(1, 1) = 1;
 
   std::cout << (matrix  + matrix2);
 
   return 0;
}
 
// ------------------------------------------------------------
template < class T >
std::ostream& operator<<(std::ostream& out, const Matrix<T>& matrix)
{
   const int m = matrix.getNumColumns();
   const int n = matrix.getNumRows();
 
   for (int i = 0; i < m; ++i)
   {
      for (int j = 0; j < n; ++j)
      {
         out << matrix.at(i, j) << ' ';
      }
 
      out << std::endl;
   }
 
   return out;
}

#ifndef MATRIX_HPP
#define MATRIX_HPP
 
#include "bad_matrix.hpp"
#include "incompatible_matrix.hpp"
 
#include <vector>
 
template<class T>
class Matrix
{
public:
   explicit
   Matrix(const int _m, const int _n);
   explicit
   Matrix(const Matrix<T>& other);
   Matrix<T>& operator=(const Matrix<T>& other);
   virtual
   ~Matrix();
   Matrix operator+(const Matrix<T>& other);
   Matrix operator-(const Matrix<T>& other);
   Matrix operator*(const Matrix<T>& other);
   // умножение вектора на скалярное число
   Matrix operator*(const long x);
   Matrix operator*(const double& x);
   void operator+=(const Matrix<T>& other);
   void operator-=(const Matrix<T>& other);
   void operator*=(const Matrix<T>& other);
   bool operator==(const Matrix<T>& other);
 
   // Возвращает детерминант для квадратной матрицы
   T determinant();
   inline
   bool isSquare() const;
 
   inline
   long getNumRows() const;
 
   inline
   long getNumColumns() const;
 
   inline
   T& at(long i, long j) { return matrix[i][j]; }
 
   inline
   const T& at(long i, long j) const { return matrix[i][j]; }
 
   Matrix<T> pow(int power);
private:
   long int numRows;
   long int numColumns;
   std::vector< std::vector<T> > matrix;
 
};
// ----------------------------------------------------------
template< class T >
Matrix<T>::Matrix(const int _m, const int _n) :
   numRows(_m), numColumns(_n)
{
   // основной констурктор
   if (numRows <= 0 || numColumns <= 0)
   {
      throw bad_matrix("invalid dimension for matrix");
   }
 
   matrix.resize(numRows);
   for (auto &it : matrix)
   {
      it.resize(numColumns);
   }
 
   for (auto &it : matrix)
   {
      std::fill(it.begin(), it.end(), 0);
   }
}
// ----------------------------------------------------------
/* конструктор копирования */
template< class T >
Matrix<T>::Matrix(const Matrix<T>& other) :
   numRows(other.getNumRows()), numColumns(other.getNumColumns())
{
 
   matrix.resize(numRows); // изменяем размер контейнера до минимально необходимого
   for (auto &it : matrix)
   {
      it.resize(numColumns);
   }
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numRows; ++j)
      {
         matrix[i][j] = other.at(i, j);
      }
   }
}
// ----------------------------------------------------------
template<class T>
Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other)
{
   numRows = other.getNumRows();
   numColumns = other.getNumColumns();
 
   matrix.resize(numRows);
   for (auto &it : matrix)
   {
      it.resize(numColumns);
   }
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numRows; ++j)
      {
         matrix[i][j] = other.at(i, j);
      }
   }
 
   return (*this);
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator+(const Matrix<T>& other)
{
   if (numRows != other.getNumRows() || numColumns != other.getNumColumns())
   {
      // если матрицы имеют разные размеры для них не определена операция сложения
      throw bad_matrix();
   }
 
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix.at(i , j) += other.at(i, j);
      }
   }
 
   return resultMatrix;
}
// ----------------------------------------------------------
template< class T >
void Matrix<T>::operator+=(const Matrix<T>& other)
{
   *this = (*this) + other;
}
// ----------------------------------------------------------
template< class T >
Matrix<T>::~Matrix()
{
}
// ----------------------------------------------------------
template< class T >
long Matrix<T>::getNumRows() const
{
   return numRows;
}
// ----------------------------------------------------------
template< class T >
long Matrix<T>::getNumColumns() const
{
   return numColumns;
}
// ----------------------------------------------------------
template < class T >
bool Matrix<T>::isSquare() const
{
   return (numColumns == numRows);
}
// ----------------------------------------------------------
template < class T >
bool Matrix<T>::operator==(const Matrix<T>& other)
{
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         if (matrix[i][j] != other.at(i, j))
            return false;
      }
   }
 
   return true;
}
// ----------------------------------------------------------
template < class T >
Matrix<T> Matrix<T>::pow(int power)
{
   if (!isSquare())
   {
      throw bad_matrix();
   }
   if (power < 0); // FIXME сделать что-либо
 
 
   if (power == 0)
   {
      Matrix<T> resultMatrix(numRows, numColumns);
 
      for (int i = 0; i < numRows; ++i)
      {
         resultMatrix.at(i, i) = 1;
      }
 
      return resultMatrix;
   }
   else
   {
      Matrix<T> resultMatrix(*this);
 
      for (int i = 1; i < power; ++i)
      {
         resultMatrix *= (*this);
      }
 
      return resultMatrix;
   }
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator-(const Matrix<T>& other)
{
   if (numRows != other.getNumRows() || numColumns != other.getNumColumns())
   {
      // если матрицы имеют разные размеры для них не определена операция вычитания
      throw bad_matrix();
   }
 
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix.at(i , j) -= other.at(i, j);
      }
   }
 
   return resultMatrix;
}
 
// ----------------------------------------------------------
template < class T >
void Matrix<T>::operator*=(const Matrix<T>& other)
{
   *this = (*this) * other;
}
// ----------------------------------------------------------
template< class T >
void Matrix<T>::operator-=(const Matrix<T>& other)
{
   *this = (*this) - other;
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator*(const long x)
{
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix(i, j) *= x;
      }
   }
 
   return resultMatrix;
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator*(const double& x)
{
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix(i, j) *= x;
      }
   }
 
   return resultMatrix;
}
 
// ----------------------------------------------------------
#endif // MATRIX_HPP

#ifndef INCOMPATIBLE_MATRIX_HPP
#define INCOMPATIBLE_MATRIX_HPP
 
#include "bad_matrix.hpp"
 
#include <stdexcept>
 
class incompatible_matrix : public bad_matrix
{
public:
   incompatible_matrix();
   virtual ~incompatible_matrix() noexcept;
   virtual const char * what() const noexcept;
private:
   static const char * errMsg;
};
 
#endif // INCOMPATIBLE_MATRIX_HPP

#include "incompatible_matrix.hpp"
 
const char * incompatible_matrix::errMsg = "incompatible matrix";
 
incompatible_matrix::incompatible_matrix()
{
}
 
incompatible_matrix::~incompatible_matrix() noexcept
{
}
 
const char *incompatible_matrix::what() const noexcept
{
   return errMsg;
}