我正在创建一个模板化矩阵乘法函数,其中返回的矩阵与左侧矩阵的大小不同。在该函数中,我需要访问要返回的矩阵的 protected 成员,但出现编译器错误 C2248:无法访问 protected 成员。我相信这是因为模板参数的大小不同。
template<typename T, std::size_t r, std::size_t c>
struct Matrix
{
template<std::size_t c2>
Matrix<T, r, c2> operator*(const Matrix<T, c, c2>& rhs);
protected:
int test;
};
template<typename T, std::size_t r, std::size_t c>
template<std::size_t c2>
Matrix<T, r, c2> Matrix<T, r, c>::operator*(const Matrix<T, c, c2>& rhs)
{
Matrix<T, r, c2> retMat;
retMat.test;
return retMat;
}
我尝试将 operator*()
乘法函数作为 friend :
...
protected:
int test;
template<std::size_t c2>
friend Matrix<T, r, c> Matrix<T, r, c2>::operator*(const Matrix<T, c2, c>& rhs);
};
但我得到:
error C2245: non-existent member function Matrix<T,r,c>::operator * specified as friend (member function signature does not match any overload)
如何使用不同大小的模板参数参数访问 Matrix
中的 protected 变量?
最佳答案
cannot access protected member. I believe this occurs because the template arguments are different sizes.
正是:Matrix<int, 2, 3>
与(例如)Matrix<int, 3, 4>
的类型不同;所以在 Matrix<int, 2, 3>
的方法中您无法访问 test
Matrix<int, 3, 4>
的成员.
I tried friending the
operator*()
multiplication function
这是正确的方法,但您忘记了一个重要元素:a friend
函数不是类的方法;这是一个正常的功能。
如果你实现 operator*()
作为一个类的方法(由于多种原因是错误的方法),它只需要一个显式参数(*
右侧的操作数),因为另一个元素(*
左侧的操作数)隐含地, *this
元素。
但是当你执行 operator*()
作为一个函数(friend
是否属于类),没有隐含的 *this
元素;所以该函数需要两个参数。
所以你错了
template<std::size_t c2>
friend Matrix<T, r, c> Matrix<T, r, c2>::operator*(const Matrix<T, c2, c>& rhs);
因为只接收一个参数而不是 Matrix<T, r, c2>::
.
解决这个问题的正确方法(恕我直言)是一个函数(不是方法)如下
template <typename T, std::size_t D1, std::size_t D2, std::size_t D3>
Matrix<T, D1, D3> operator* (Matrix<T, D1, D2> const & m1,
Matrix<T, D2, D3> const & m2)
{
Matrix<T, D1, D3> retMat;
retMat.test = m1.test + m2.test;
return retMat;
}
那必须是 Matrix<T, D1, D2>
的 friend , Matrix<T, D2, D3>
和 Matrix<T, D1, D3>
.
你可能会想在类中定义它
template <typename T, std::size_t R, std::size_t C>
struct Matrix
{
protected:
T test;
template <typename U, std::size_t D1, std::size_t D2, std::size_t D3>
friend Matrix<U, D1, D3> operator* (Matrix<U, D1, D2> const & m1,
Matrix<U, D2, D3> const & m2)
{
Matrix<T, D1, D3> retMat;
retMat.test = m1.test + m2.test;
return retMat;
}
};
但这是错误的,因为会导致在不同类中对同一函数进行多次定义。
所以我建议声明(但不定义)operator*()
friend
在类里面
template <typename T, std::size_t R, std::size_t C>
struct Matrix
{
protected:
T test;
template <typename U, std::size_t D1, std::size_t D2, std::size_t D3>
friend Matrix<U, D1, D3> operator* (Matrix<U, D1, D2> const & m1,
Matrix<U, D2, D3> const & m2);
};
并在外部定义它。
下面是一个完整的工作示例
#include <type_traits>
template <typename T, std::size_t R, std::size_t C>
struct Matrix
{
protected:
T test;
template <typename U, std::size_t D1, std::size_t D2, std::size_t D3>
friend Matrix<U, D1, D3> operator* (Matrix<U, D1, D2> const & m1,
Matrix<U, D2, D3> const & m2);
};
template <typename T, std::size_t D1, std::size_t D2, std::size_t D3>
Matrix<T, D1, D3> operator* (Matrix<T, D1, D2> const & m1,
Matrix<T, D2, D3> const & m2)
{
Matrix<T, D1, D3> retMat;
retMat.test = m1.test + m2.test;
return retMat;
}
int main ()
{
Matrix<long, 2U, 3U> a;
Matrix<long, 3U, 4U> b;
auto c { a * b };
static_assert( std::is_same<decltype(c), Matrix<long, 2U, 4U>>{}, "!" );
}
关于具有不同模板参数值的模板结构的 C++ 访问 protected 成员,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/50558087/