Code de gestion de matrices, merci de le critiquer

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <vector>

template<class T>
class Matrix
{
private:
   int _nbLignes, _nbColonnes;
   std::vector<std::vector<T>> _v;
   void setElement(int l, int c, T v);
   Matrix():_nbLignes(0),_nbColonnes(0){};

public:
   Matrix(int, int);
   Matrix(const Matrix&);

   void operator+=(const Matrix&);
   void operator-=(const Matrix&);

   Matrix operator+(const Matrix&) const;
   Matrix operator-(const Matrix&) const;

   T operator()(int, int) const;

   int getNbLignes() const{return _nbLignes;}
   int getNbColonnes() const{return _nbColonnes;}

   //initialise
   void fill(T value);

   int set(int l, int c, T v);

   bool operator==(const Matrix&) const;

};

template<class T>
std::ostream& operator << (std::ostream& out, const Matrix<T>& m)
{
  for(int i=0; i<m.getNbLignes(); i++)
  {
     out << "|" ;

     for(int j=0; j<m.getNbColonnes(); j++)
        out << " " << m(i,j) << " " ;

     out << "|" << std::endl;
  }
return out;
}

template<class T>
Matrix<T>::Matrix(int nbLignes, int nbColonnes):_nbLignes(nbLignes), _nbColonnes(nbColonnes)
{
   _v.resize(nbLignes);
   for(int i=0; i<nbLignes; i++)
      _v[i].resize(nbColonnes);
}

template<class T>
Matrix<T>::Matrix(const Matrix<T>& m)
{
   _nbLignes = m._nbLignes;
   _nbColonnes = m._nbColonnes;

   _v.resize(_nbLignes);
   for(int i=0; i<_nbLignes; i++)
      _v[i].resize(_nbColonnes);

   for(int i=0; i<_nbLignes; i++)
      for(int j=0; j<_nbColonnes; j++)
         setElement(i,j,m(i,j));
}

template<class T>
void Matrix<T>::operator+=(const Matrix<T>& m)
{
   if ((_nbLignes != m._nbLignes)||(_nbColonnes != m._nbColonnes))
   {
       std::cout << "addition impossible !!" << std::endl;
       return ;
   }

for(int i=0; i<_nbLignes; i++)
   for(int j=0; j<_nbColonnes; j++)
      this->setElement(i,j,m(i,j)+_v[i][j]);
}

template<class T>
void Matrix<T>::operator-=(const Matrix<T>& m)
{
   if ((_nbLignes != m._nbLignes)||(_nbColonnes != m._nbColonnes))
   {
       std::cout << "soustraction impossible !!" << std::endl;
       return ;
   }

for(int i=0; i<_nbLignes; i++)
   for(int j=0; j<_nbColonnes; j++)
      this->setElement(i,j,_v[i][j]-m(i,j));
}

template<class T>
Matrix<T> Matrix<T>::operator+(const Matrix<T>& m) const
{
   if ((_nbLignes != m._nbLignes)||(_nbColonnes != m._nbColonnes))
   {
      std::cout << "addition impossible !!" << std::endl;
      return Matrix<T>();
   }

   Matrix result(*this);
   result+=m;
   return result;
}

template<class T>
Matrix<T> Matrix<T>::operator-(const Matrix<T>& m) const
{
   if ((_nbLignes != m._nbLignes)||(_nbColonnes != m._nbColonnes))
   {
      std::cout << "soustraction impossible !!" << std::endl;
      return Matrix<T>();
   }

   Matrix result(*this);
   result-=m;
   return result;
}

template<class T>
T Matrix<T>::operator()(int row, int col) const
{
   return (this->_v[row])[col];
}

//initialiser
template<class T>
void Matrix<T>::fill(T value)
{
   for(int i=0; i<_nbLignes; i++)
      for(int j=0; j<_nbColonnes; j++)
         this->setElement(i,j,value);
}

template<class T>
void Matrix<T>::setElement(int row, int col, T value)
{
   (_v[row])[col] = value;
}

template<class T>
int Matrix<T>::set(int row, int col, T value)
{
   if(row>0 && col>0 && row<=_nbLignes && col<_nbColonnes)
      (_v[row-1])[col-1] = value;
   else
      return -1;

   return 0;
}

template<class T>
bool Matrix<T>::operator==(const Matrix<T>& m) const
{
   if(_nbLignes!= m._nbLignes || _nbColonnes!=m._nbColonnes)
      return false;

   for(int i=0; i<_nbLignes; i++)
      for(int j=0; j<_nbColonnes; j++)
         if (_v[i][j]!= m(i,j)) return false;

   return true;
}

#endif 

template<class T>
Matrix<T>::Matrix(const Matrix<T>& m)
{
   _nbLignes = m._nbLignes;
   _nbColonnes = m._nbColonnes;

template<class T>
Matrix<T>::Matrix(const Matrix<T>& m)
 : _nbLignes(m._nbLignes), _nbColonnes (m._nbColonnes)
{

   _v.resize(_nbLignes);
   for(int i=0; i<_nbLignes; i++)
      _v[i].resize(_nbColonnes);

   for(int i=0; i<_nbLignes; i++)
      for(int j=0; j<_nbColonnes; j++)
         setElement(i,j,m(i,j));

   _v.resize(_nbLignes);
   for(int i = 0; i < _nbLignes; ++i)
  {
      _v[i].resize(_nbColonnes);
      for(int j = 0; j < _nbColonnes; ++j)
         setElement(i,j,m(i,j));
  }

   if ((_nbLignes != m._nbLignes)||(_nbColonnes != m._nbColonnes))
   {
       std::cout << "addition impossible !!" << std::endl;
       return ;
   }

   if ((_nbLignes != m._nbLignes)||(_nbColonnes != m._nbColonnes))
      throw MatrixException("addition impossible !!");

template<class T>
T Matrix<T>::operator()(int row, int col) const
{
   return (this->_v[row])[col];
}

template<class T>
T Matrix<T>::operator()(int row, int col) const
{
   return _v[row][col];
}

(_v[row])[col] = value;

_v[row][col] = value;

if(row>0 && col>0 && row<=_nbLignes && col<_nbColonnes)
      (_v[row-1])[col-1] = value;
   else
      return -1;

   return 0;

if( row < 0 || col < 0 || row > _nbLignes || col > _nbColonnes)
  throw MatrixException("Index out of bound");

_v[row-1][col-1] = value;

if (_v[i][j]!= m(i,j)) return false;

if (_v[i][j]!= m._v[i][j]) return false;

template<class T>
void Matrix<T>::print(std::ostream& out) const
{
  for(int i = 0; i<m._nbLignes; ++i)
  {
     out << "|";
     for(int j = 0; j < m._nbColonnes; ++j)
        out << " " << m._v[i][j] << " ";
     out << "|" << std::endl;
  }
}

template<class T>
std::ostream& operator<<(std::ostream& out, const Matrix<T>& m)
{
  m.print(out);
  return out;
}