C++ 在模板类中重载 operator+

Question

template<typename T>
class Matrix
{

    template<typename U>
    friend
    Matrix<U> operator+(const Matrix<U>& a, const Matrix<U>& b);


protected:

    size_t _m, _n;
    T *_alloc;
};

template<typename U>
Matrix<U> operator+(const Matrix<U>& a, const Matrix<U>& b)
{
    if(a._m == b._m && a._n == b._n)
    {
        Matrix<U> ret(a._m, a._n);

        // ...

        return ret;
    }
    else
    {
        throw "Matrix dimension mismatch error";
    }
}

我重载了 operator+在使用非模板类没有问题之前。我在这里使用模板类。

Matrix<U> Matrix<U>::operator+(const Matrix<U>&, const Matrix<U>&)必须采用零个或一个参数。

编译器似乎忽略了 friend关键字。

我也试过

friend
template<typename U>
Matrix<U> operator+(const Matrix<U>& a, const Matrix<U>& b);

但这给了我一个不同的编译器错误。

expected unqualified-id before 'template'

如何重载 operator+与模板类？

Answer 1

您可以使用成员函数或非成员函数重载 + 运算符。

当使用成员函数重载运算符时，运算符的左轴是调用函数的对象，运算符的右轴是函数的参数。因此，成员函数的唯一参数将是 RHS。

当使用非成员函数重载运算符时，运算符的左轴是函数的第一个参数，运算符的右轴是函数的第二个参数。

成员函数

template<typename T>
class Matrix
{
  Matrix operator+(const Matrix& rhs) const {
    ...
  }
};

如果你想在类定义之外实现它，你可以使用:

template<typename T>
  Matrix<T> Matrix<T>::operator+(const Matrix& rhs) const {
    ...
  }

非成员函数

template<typename T>
class Matrix
{
  Matrix operator+(const Matrix& lhs, const Matrix& rhs) {
    ...
  }
};

如果要在类定义之外实现，需要添加一些前向声明代码:

// Forward declare the class template
template <typename T> class Matrix;

// Declare the function
template <typename T> Matrix<T> operator+(const Matrix<T>& lhs, const Matrix<T>& rhs);

// Declare the friend in the class definition
template <typename T>
class Matrix
{
   friend Matrix operator+<T>(const Matrix& lhs, const Matrix& rhs);
   //                     ^^^^ 
   // This makes operator+<int> a friend of Matrix<int>, not a friend
   // of Matrix<double>
};

然后实现功能

template <typename T> Matrix<T> operator+(const Matrix<T>& lhs, const Matrix<T>& rhs)
{
    ...
}

有了这个设置，oprator+<int>是Matrix<int>的 friend 只有，不是 friend的 Matrix<double> .

如果你使用

template <typename U>
friend
Matrix<U> operator+(const Matrix<U>& a, const Matrix<U>& b);

然后，operator+ 的所有实例化是 Matrix 的所有实例化的 friend ，您不需要。

更新

示例工作代码:

#include <iostream>
 
// Forward declare the class template
template<typename T> class Matrix;

// Declare the function
template <typename T> Matrix<T> operator+(const Matrix<T>& lhs, const Matrix<T>& rhs);

// Declare the friend in the class definition
template <typename T>
class Matrix
{
   friend Matrix operator+<T>(const Matrix& lhs, const Matrix& rhs);
   //                     ^^^^ 
   // This makes operator+<int> a friend of Matrix<int>, not a friend
   // of Matrix<double>
};

template <typename T> Matrix<T> operator+(const Matrix<T>& lhs, const Matrix<T>& rhs)
{
   return Matrix<T>{};
}

int main()
{
   Matrix<int> a;
   Matrix<int> b;
   Matrix<int> c = a + b;
}