C ++-使运算符重载可链接

Question

因此，我试图为我的“ Matrix”类（+和+ =）重载两个运算符。我试图使+可链接，而+=不可链接：

template <class T>
Matrix<T>& Matrix<T>::operator+=(const Matrix& M) 
{
  if (this->m_capacity != M.capacity()) 
  {
    throw std::out_of_range("Input is invalid");
  }

  for (unsigned int i = 0; i < M.rows(); i++) 
  {
    for (unsigned int j = 0; j < M.cols(); j++) 
    {
      this->m_vec[i + m_cols * j] += M(i, j);
    }
  }
  return *this;
}


template <class T>
Matrix<T> operator+(Matrix<T> M1, Matrix<T>& M2) 
{
  if (M1.capacity() != M2.capacity()) 
  {
    throw std::out_of_range("Input is invalid");
  }

  return M1 += M2;
}

它编译得很好，没有问题，但是当我尝试对此进行单元测试时，尝试链接+运算符时，整个测试程序就会崩溃。

示例：

TEST(add, Matrix)
{
  Matrix<int> M1 = Matrix<int>(2, 3);
  Matrix<int> M2 = { 1, 2, 3, 4 };
  Matrix<int> M3 = M2;
  Matrix<int> M4 = { 2, 4, 6, 8 };

  ASSERT_THROW(M1 + M2, std::out_of_range);
  ASSERT_EQ((M2 + M3) == M4, true);

  M2 += M3;
  M2 = M4 + M4 + M4; // As soon as this line is added, it crashes, without it, test works fine

  ASSERT_EQ(M2 == M4, true);
}

任何想法为什么会崩溃？如何重写我的运算符重载，以使´+´可链接（而不是+=）？

编辑：这是我的=运算符（应要求提供）

template <class T>
void Matrix<T>::operator=(Matrix & M){
  T*temp = new T[M.m_capacity];
  for(unsigned int  j = 0; j < M.m_capacity; j++){
    temp[j] = M.m_vec[j];
  }
  delete[] this -> m_vec;
  size_t rows = M.get_m_rows();
  size_t cols = M.get_m_cols();
  this -> m_rows = rows;
  this -> m_cols = cols;
  this -> m_vec = new T [rows*cols];
  this -> m_capacity = rows*cols;
  for(size_t i = 0;i < rows;i++){
    for(size_t j = 0;j < cols;j++){
      this -> m_vec[i*cols+j] = temp[i*cols +j];
    }
  }
  delete [] temp;
}

EDIT2：添加了更多上下文（根据请求，标头，构造函数等）

标题：

template <class T>
class Matrix {
public:
   // constructor
   Matrix(unsigned int n);
   Matrix(unsigned int n, unsigned int m);
   Matrix();
   Matrix(const T n);
   Matrix(Matrix &obj);
   ~Matrix();
   Matrix(Matrix &&obj);
   Matrix(std::initializer_list<T> l);

   // operators
   void operator=(Matrix & obj);
   T& operator()(unsigned int row, unsigned int col);
   Matrix& operator=( Matrix &&obj);
   Matrix& operator+=(const Matrix& M)
   void operator+=(const T number);
   void operator-=(const T number);
   void operator-=(Matrix &obj);
   void operator*=(const T number);
   void operator*=(Matrix &obj);
   bool operator==(Matrix & rhs);

private:
   std::size_t m_rows;
   std::size_t m_cols;
   std::size_t m_capacity;
   T * m_vec;
};

复制构造函数：

template <class T>
Matrix<T>::Matrix(Matrix &obj){
  size_t rows = obj.get_m_rows();
  size_t cols = obj.get_m_cols();
  this -> m_rows = rows;
  this -> m_cols = cols;
  this -> m_vec = new T [rows*cols];
  this -> m_capacity = rows*cols;
  for(size_t i = 0;i < rows;i++){
    for(size_t j = 0;j < cols;j++){
      this -> m_vec[i*cols+j] = obj(i,j);
    }
  }
}

析构函数：

template  <class T>
Matrix<T>::~Matrix(){
  delete [] m_vec;
}

移动构造函数（可能已损坏）

template <class T>
Matrix<T>::Matrix(Matrix &&obj){
  size_t rows = obj.get_m_rows();
  size_t cols = obj.get_m_cols();
  this -> m_rows = rows;
  this -> m_cols = cols;
  this -> m_vec = new T [rows*cols];
  this -> m_capacity = rows*cols;
  m_vec = nullptr;
}

移动分配（可能已损坏）

template <class T>
Matrix<T>& Matrix<T>::operator=(Matrix &&obj){
  if (this !=&obj)
  {
    delete [] m_vec;
    obj.m_rows = 0;
    obj.m_cols = 0;
    obj.m_capacity = 0;
    obj.m_vec = nullptr;
  }
  return *this;
  }

Answer 1

您的move构造函数和move赋值运算符都没有实现正确的语义（似乎您已经意识到这一点），导致UB稍后出现。 （我没有去检查确切的位置。）

我猜您以为您实际上并未调用这些运算符，但这是错误的。

您正在以=的符号调用移动分配运算符>

M2 = M4 + M4 + M4;
因为右侧是可以绑定到右值引用的prvalue（operator+返回按值）。

[您正在同一行的第二个+处调用move构造函数以构造operator+=的第一个参数，因为第一个+会产生prvalue。

如果您打算稍后实现移动操作，并且暂时可以使用复制实现，那么就不要在您的类中声明移动操作。然后，编译器将选择您的复制实现。

此外，副本构造函数和副本赋值运算符应始终

将const（左值）引用作为参数，而不是非const引用。

Answer 2

我不确定，但是由于您的+ =运算符是破坏性的，因为它不会返回单独的矩阵，而是会覆盖前一个矩阵，所以将m4本身添加可能会引起奇怪的错误，因为“ this”正在得到加和回报不断变化。无论如何，由于编译器始终将操作符带入二进制操作序列，因此没有理由使操作符可链接，因此问题很可能与+ =重载的结构有关。另外，在+重载内添加并将x + = x定义为x = x + x而不是反过来更有意义。