c++ - 重载模板化类二元运算符*

Question

我正在编写一个 2D 矩阵模板来学习模板和一些 C++11 功能。

写了下面的标题:

template <class T, unsigned int Rows, unsigned int Columns>
class Matrix2D
{
private:
    array<array<T,Columns>, Rows> m_Matrix;

public:
    Matrix2D() {}

    array<T,Columns>& operator[](unsigned int row)       { return m_Matrix[row]; } ;
    const array<T,Columns>& operator[](unsigned int row) const { return m_Matrix[row]; } ;

    friend Matrix2D operator+ <> (const Matrix2D &lhs, const Matrix2D &rhs);
    friend Matrix2D operator* <> (const Matrix2D &lhs, const Matrix2D &rhs);
};

operator+ 工作正常 - 我有一个实现，它编译、链接并通过调试器单步执行。

问题出在 operator* 上，我得到了编译错误

1>...\matrix2d.h(18): error C2143: syntax error : missing ';' before '<'
1>...\matrix2d.h(19) : see reference to class template instantiation 'Matrix2D<T,Rows,Columns>' being compiled

没有一行代码尝试使用运算符，所以是定义本身错误，我只是不明白为什么。

有人能帮忙吗？

编辑:(从评论中添加)

template <class T, unsigned int Rows, unsigned int Columns>
Matrix2D<T, Rows, Columns> operator+ (const Matrix2D<T, Rows, Columns> &lhs, const Matrix2D<T, Rows, Columns> &rhs)
{
    Matrix2D<T, Rows, Columns> addResult;
    for (unsigned int i = 0; i < Rows; i++)
        for (unsigned int j = 0; j < Columns; j++)
            addResult[i][j] = lhs[i][j] + rhs[i][j];
    return addResult;
}

template <class T, unsigned int Rows, unsigned int Columns>
Matrix2D<T, Rows, Columns> operator* (const Matrix2D<T, lRows, lColumns> &lhs, const Matrix2D<T, rRows, rColumns> &rhs)
{
    Matrix2D<T, lRows, rColumns> mulResult;

    for(unsigned int i = 0; i < lRows; i++)
        for(unsigned int j = 0; j < rColumns; j++)
            for (unsigned int k = 0; k < lColumns; k++)
                mulResult[i][k] += lhs[i][k] * rhs[k][j];
    return addResult;
}

Answer 1

您不能将未声明的模板函数的特化作为好友。当然，在定义类模板之前声明运算符也需要您转发声明它:

template <class T, unsigned int Rows, unsigned int Columns>
class Matrix2D;

template <class T, unsigned int Rows, unsigned int Columns>
Matrix2D<T, Rows, Columns>
operator+ (const Matrix2D<T, Rows, Columns> &lhs, const Matrix2D<T, Rows, Columns> &rhs);

template <class T, unsigned int Rows, unsigned int Columns>
Matrix2D<T, Rows, Columns>
operator* (const Matrix2D<T, Rows, Columns> &lhs, const Matrix2D<T, Rows, Columns> &rhs);

template <class T, unsigned int Rows, unsigned int Columns>
class Matrix2D
{
private:
    array<array<T,Columns>, Rows> m_Matrix;

public:
    Matrix2D() {}

    array<T,Columns>& operator[](unsigned int row)       { return m_Matrix[row]; }
    const array<T,Columns>& operator[](unsigned int row) const { return m_Matrix[row]; }

    friend Matrix2D operator+ <> (const Matrix2D &lhs, const Matrix2D &rhs);
    friend Matrix2D operator* <> (const Matrix2D &lhs, const Matrix2D &rhs);
};

或者，您可以采用简单的方法，为 Matrix2D 的每个特化定义单独的运算符函数:

template <class T, unsigned int Rows, unsigned int Columns>
class Matrix2D
{
private:
    array<array<T,Columns>, Rows> m_Matrix;

public:
    Matrix2D() {}

    array<T,Columns>& operator[](unsigned int row)       { return m_Matrix[row]; }
    const array<T,Columns>& operator[](unsigned int row) const { return m_Matrix[row]; }

    friend Matrix2D operator+ (const Matrix2D &lhs, const Matrix2D &rhs) {
        // do stuff that adds.
    }
    friend Matrix2D operator* (const Matrix2D &lhs, const Matrix2D &rhs) {
        // do stuff that multiplies.
    }
};

我可能会将其用于更简单的整体语法。

编辑:非方矩阵的适当乘法意味着 operator* 函数实际上需要成为 Matrix2D 的三种不同特化的 friend :左操作数、右操作数和结果。我认为这里的第一种方法将变得站不住脚。您应该将 operator* 的所有特化加为好友:

template <class T, unsigned int Rows, unsigned int Columns>
class Matrix2D
{
  // ...

  template <typename U, typename V, unsigned Rows, unsigned Common, unsigned Columns>
  friend Matrix2D<decltype(std::declval<U>()+std::declval<V>()), Rows, Columns>
  operator * (const Matrix2D<U, Rows, Common>&,
              const Matrix2D<V, Common, Columns>&);

};

或者简单地公开数据(无论如何，这可能是“数据收集”类的最佳方法)。