关于模板类的未绑定模板友元函数的返回类型

Question

假设我有一个模板类，它有一个模板友元函数希望实现一个值乘以一个数组（myArray）的函数：

template<typename T, int size>
class myArray{
  T *_array;
public:
  ...
  template<typename Val, typename Array> 
  friend myArray<T,size> operator*(const Val &lhs, const Array &rhs){
    myArray<T,size> mat_t;
    for(int i = 0;i < size; i++)
      mat_t._array[i] = lhs * rhs._array[i];
    return mat_t;
}
  ...
};

它适用于 VS2013。然后我把未绑定模板友元函数的定义移到外面：

template<typename Val, typename Array>
myArray<T,size> operator*(const Val &lhs, const Array &rhs){
  myArray<T,size> mat_t;
  for(int i = 0;i < size; i++)
    mat_t._array[i] = lhs * rhs._array[i];
  return mat_t;
}

这是不正确的！我想问题出在朋友函数的返回类型上。但我想不通。 那么如何在类声明之外定义这样的友元模板函数呢？

Answer 1

friend 像第一个例子一样声明的函数是奇怪的野兽。 myArray<T,Size> 的每个实例都会创建一个distinct friend 函数，该函数只能通过myArray<T,Size> 上的参数相关查找来找到。

免费的operator* 没有这样声明是行不通的。

你可以让你的代码像这样工作：

template<class Val, class T, int size>
myArray<T,size> operator*(const Val &lhs, const myArray<T,size> &rhs){
  myArray<T,size> mat_t;
  for(int i = 0;i < size; i++)
    mat_t._array[i] = lhs * rhs._array[i];
  return mat_t;
}

这里所有的模板参数都列在template<>列表中，它们都可以从*的参数中推导出来。

记得将operator* 与myArray 放在同一个命名空间中。

但是，就个人而言，我会选择：

friend myArray operator*(const T&lhs, const myArray &rhs){
  myArray mat_t;
  for(int i = 0;i < size; i++)
    mat_t._array[i] = lhs * rhs._array[i];
  return mat_t;
}

非template 的朋友operator*。同样，其中一个是为每个myArray<T,size>“生成”的，但它本身不是template。这有一定的优势，比如它在转换构造函数中表现得更好。

更进一步，我们得到：

friend myArray& operator*=(myArray&mat, const T&scalar){
  for(int i = 0;i < size; i++)
    mat._array[i] *= scalar;
  return mat;
}
friend myArray operator*(const T&scalar, myArray mat){
  mat *= scalar;
  return mat;
}
friend myArray operator*(myArray mat, const T&scalar){
  mat *= scalar;
  return mat;
}

我们首先创建一个*=，然后根据它写*。请注意，* 采用 myArray 的值（因为无论如何我都需要返回一个副本，不妨让它发生在方法之外），并且我同时支持 mat*scalar 和 scalar*mat 和 mat*=scalar。

另请注意，矩阵的矩阵......只是工作。

friend operator 是一个好主意的原因在 here 中进行了说明。请注意，代码无法编译。现在#define ADL to move the operator* into the class as friends 编译。 Koenig 运算符让 operator* 可以在 template 类上运行而不是模板，并且模板的参数匹配规则很难在没有过窄、过宽或使用讨厌的 SFINAE 的情况下正确。

下一步，operator*= 可以通过以下方式改进：（为简洁起见，使用 C++14）

template<class Array
  class=std::enable_if_t<std::is_same<std::decay_t<Array>,myArray>>
>
friend Array operator*=(Array&&mat, const T&scalar){
  for(int i = 0;i < size; i++)
    mat._array[i] *= scalar;
  return std::forward<Array>(mat);
}

这更复杂，但通过完美的转发做有趣的事情。临时的myArray 将moved 放入返回值（允许引用生命周期延长工作），而非临时的myArray 返回一个引用。

这提供了为什么即使*= 也应该是friend 的原因。它允许在同一个方法中实现 r 值和左值。

另一方面，您可能不希望*= 使用右值。在这种情况下，请使用带有 & 参考类别限定符的常规方法来消除该选择。

Answer 2

T和size是myArray的模板参数。如果您将包含这些模板参数的函数定义放在myArray 的定义之外，则必须再次声明它们是模板参数，例如

template <typename T, int size, typename Val, typename Array>

但是，即使您编译它也对您没有多大帮助，因为您将无法实际正确调用运算符，因为编译器无法推断出模板参数 T 和 @987654330 @。这个电话必须是像

这样尴尬的东西

auto a = operator*<double, 4>(22, someArray);

您可能希望创建一个只返回与其第二个参数相同类型的函数 - 无论如何其他任何事情都没有多大意义。为了避免模板友元声明的困难（很难做到正确）以及与友元的紧密耦合，您可以将运算符中继到公共乘法函数，或者更好的是 operator*=

template<typename T, int size>
class myArray {
  T *_array;
public:
  myArray() : _array(new T[size]{22}) {}
  //...
  template<typename Val> 
  myArray& operator*=(const Val &val) {
    for (int i = 0; i < size; ++i) 
      _array[i] *= val  ;
    return *this;
  }
};

template <typename Val, typename T, int size>
myArray<T,size> operator*(const Val &lhs, myArray<T, size> tmp) {
  tmp *= lhs; 
  return tmp;
}      

关于为什么operator*= 应该是一个成员函数而不是一个免费的朋友函数，请参阅this link