Question

我正在编写一个矩阵基类，并将问题作为标题来解决。

这是我的声明。

template <typename T, size_t m, size_t n, typename _Prd>
template <size_t _m, size_t _n>
const Matrix<T,m,_n,_Prd> operator* (const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd>& rhs) ; // matrix mult

和班里的朋友宣言。

template <size_t _m, size_t _n>
friend const Matrix<T,m,_n,_Prd> operator* <>(const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd>& rhs) ;

并实施：

template <typename T, size_t m, size_t n, typename _Prd>
template <size_t _m, size_t _n>
const Matrix<T,m,_n,_Prd> operator* (const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd>& rhs) 
{
    assert (n == _m) ;
    Matrix<T,m,_n,_Prd> result ;

    for (size_t j = 0 ; j < m ; ++j)
        for (size_t i = 0 ; i < _n ; ++ i)

            for (size_t k = 0 ; k < n ; ++ k) 
                result.at(j,i) += lhs.at(j,k) * rhs.at(k,i) ;

    return result ;
}

但是这些不能编译，错误是：

In file included from main.cpp:13:
Matrix.hpp:43: error: too many template-parameter-lists
Matrix.hpp:66: error: invalid use of template-id ‘operator*<>’ in declaration of primary template
In file included from main.cpp:13:
Matrix.hpp:364: error: too many template-parameter-lists

我在同一个班级no matching function when return different template type from the original

遇到了另一个问题

更新：

我根据下面的建议进行了修改，但仍然无效。

转发声明：

template <typename T, size_t m, size_t n, typename _Prd,size_t _m, size_t _n>
const Matrix<T,m,_n,_Prd> operator* (const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd>& rhs) ; // matrix mult

课堂内的朋友声明：

template <size_t _m, size_t _n>
friend const Matrix<T,m,_n,_Prd> operator* (const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd>& rhs) ;

实施：

template <typename T, size_t m, size_t n, typename _Prd,size_t _m, size_t _n>

const Matrix<T,m,_n,_Prd> operator* (const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd>& rhs) 
{
    assert (n == _m) ;
    Matrix<T,m,_n,_Prd> result ;

    for (size_t j = 0 ; j < m ; ++j)
        for (size_t i = 0 ; i < _n ; ++ i)

            for (size_t k = 0 ; k < n ; ++ k) 
                result.at(j,i) += lhs.at(j,k) * rhs.at(k,i) ;

    return result ;
}

但是当我想这样使用它时：

Matrix<double,2,3> testmat8(10.0) ;
Matrix<double,3,4> testmat9(2.0) ;
Matrix<double,2,4> testmat10 ;
testmat10 = testmat8 * testmat9 ;

错误是：

main.cpp:143: undefined reference to `Matrix<double, 2ul, 4ul, std::equal_to<double> > const operator*<3ul, 4ul>(Matrix<double, 2ul, 3ul, std::equal_to<double> > const&, Matrix<double, 3ul, 4ul, std::equal_to<double> > const&)'

尚未解决......

UPDATE2：

为了澄清我的目的，我编写了3个解决方法。然而，并非所有这些都按预期工作。

//member operator * rather than friend function
template <typename T, size_t m, size_t n, typename _Prd>
template<size_t _m, size_t _n>
Matrix<T,m,_n,_Prd> Matrix<T,m,n,_Prd>::operator *(const Matrix<T,_m,_n,_Prd> & rhs) const 
{
    assert (n == _m) ;
    Matrix<T,m,_n,_Prd> result ;
    for (size_t j = 0 ; j < m ; ++j)
        for (size_t i = 0 ; i < _n ; ++ i)
            for (size_t k = 0 ; k < n ; ++ k) 
                result.at(j,i) += this->at(j,k) * rhs.at(k,i) ;
    return result ;
}


//work around for *
template <typename T, size_t m, size_t n, typename _Prd>
template<size_t _m, size_t _n>
void Matrix<T,m,n,_Prd>::mul (Matrix<T,m,_n,_Prd> & result, const Matrix<T,m,n,_Prd> & A, const Matrix<T,_m,_n,_Prd> & B) 
{
    assert (n == _m) ;
    for (size_t j = 0 ; j < m ; ++j)
        for (size_t i = 0 ; i < _n ; ++ i)

            for (size_t k = 0 ; k < n ; ++ k) 
                result.at(j,i) += A.at(j,k) * B.at(k,i) ;
}

template <typename T, size_t m, size_t n, typename _Prd>
template<size_t _m, size_t _n>
Matrix<T,m,_n,_Prd> Matrix<T,m,n,_Prd>::mul(const Matrix<T,_m,_n,_Prd> & B) const 
{
    assert (n == _m) ;
    Matrix<T,m,_n,_Prd> result ;

    for (size_t j = 0 ; j < m ; ++j)
        for (size_t i = 0 ; i < _n ; ++ i)

            for (size_t k = 0 ; k < n ; ++ k) 
                result.at(j,i) += this->at(j,k) * B.at(k,i) ;

    return result ;
}

我以这种方式打电话给他们：

    testmat10 = testmat8 * testmat9 ; //works, but I have to comment out the friend operator * overload outside of the class.
    testmat10 = testmat8.mul(testmat9) ; //works, but mul() has to be a member, not as expected as a friend .
    Matrix<double,2,3>::mul(testmat10, testmat8, testmat9) ; 
//works, but this is ridiculous, for a static function, how would I avoid use <double,2,3> as the testmat8's template before using mul? I shouldn't have used template when I use mul in this way.

但我想要的答案是有人可以澄清为什么非会员运营商*不能与第一个mul（）做同样的事情？什么是编码矩阵乘法函数的正确方法？

更新3 :(已解决） 感谢jpalecek，我根据他的回答修改了我的代码。

转发声明：

template < typename T, size_t m, size_t n, typename _Prd, size_t _m, size_t _n> 
const Matrix<T,m,_n,_Prd> operator * (const Matrix<T,m,n,_Prd>& lhs, const Matrix<T,_m,_n,_Prd> & rhs) ;

朋友声明：

// here is tricky
template <typename U, size_t mm, size_t nn, typename _Prd2, size_t _m, size_t _n>
friend const Matrix<U,mm,_n,_Prd2> operator* (const Matrix<U,mm,nn,_Prd2>& lhs, const Matrix<U,_m,_n,_Prd2>& rhs) ;

实现：

template <typename U, size_t mm, size_t nn, typename _Prd2, size_t _m, size_t _n>
const Matrix<U,mm,_n,_Prd2> operator* (const Matrix<U,mm,nn,_Prd2>& lhs, const Matrix<U,_m,_n,_Prd2>& rhs) 
{
    return lhs.mul(rhs) ;
}

mul（）作为成员函数：

template <typename T, size_t m, size_t n, typename _Prd>
template<size_t _m, size_t _n>
Matrix<T,m,_n,_Prd> Matrix<T,m,n,_Prd>::mul(const Matrix<T,_m,_n,_Prd> & B) const 
{
    assert (n == _m) ;
    Matrix<T,m,_n,_Prd> result ;
    for (size_t j = 0 ; j < m ; ++j)
        for (size_t i = 0 ; i < _n ; ++ i)
            for (size_t k = 0 ; k < n ; ++ k) 
                result.at(j,i) += this->at(j,k) * B.at(k,i) ;
    return result ;
}

用法：

//test * operator, all work
Matrix<double,2,3> testmat8(10.0) ;
Matrix<double,3,4> testmat9(2.0) ;
Matrix<double,4,4> testmat11(3.0) ;
Matrix<double,2,4> testmat10 ;
testmat10 = testmat8 * testmat9 * testmat11;
cout <<testmat10<<endl ;
testmat10 = testmat8.mul(testmat9) ;
cout << testmat10 << endl ;

Answer 1

您的语法无效。您正在将模板参数化两次：

template <typename T, size_t m, size_t n, typename _Prd>
template <size_t _m, size_t _n>

这没有明确的含义。 template<...>之后应该跟operator*的正文/声明，而不是其他template<...>。

另见："too many template-parameter-lists" error when specializing a member function

Answer 2

您面临的问题是，您不能与某个功能的部分专业化（这些不存在）或一系列专业化相关。所以它既可以是函数的所有特化，也可以是单个函数：

template <class T> class A;
template <class T, class U>
void operator*(A<T>, A<U>);

template <class T>
class A {
    template <class X, class U>
    friend void ::operator*(A<X>, A<U>);

将用于所有特化（您必须用6个参数替换参数列表），

  friend void ::operator*<>(A<T>, A<T>);

意味着一个特定的专业化（这不是你想要的）。示例here和here。

声明部分指定的模板化矩阵乘法运算符重载函数作为类外的朋友

2 个答案: