隐式转换为模板

Implicit conversion to template

本文关键字：转换      更新时间：2023-10-16

下面的例子表明，从非模板类型到模板类型的隐式转换不会像只涉及非模板类型的转换那样无缝。有没有办法让它们发挥作用？

示例：

struct point;
template<unsigned d> struct vec {
  vec() { }
  // ...
};
template<> struct vec<2> {
  vec() { }
  vec(const point& p) { /* ... */ } // Conversion constructor
  // ...
};
struct point {
  operator vec<2>() { return vec<2>(/* ... */); } // Conversion operator
};
template<unsigned d> vec<d> foo(vec<d> a, vec<d> b) {
  return vec<d>(/* ... */);
}
template<unsigned d1, unsigned d2>
vec<d1 + d2> bar(vec<d1> a, vec<d2> b) {
  return vec<d1 + d2>(/* ... */);
}
int main(int argc, char** argv) {
  point p1, p2;
  vec<2> v2;
  vec<3> v3;
  foo(v2, p1);
  foo(p2, v2);
  foo(p1, p2);
  bar(v3, p1);
}

有没有办法让这个代码从point自动转换为vec<2>

我知道我可以重载foo和bar以允许point参数，使用显式转换将其委托给vec实现。但是，对所有参数组合执行此操作将变得乏味，尤其是对于具有许多此类参数的函数。因此，我对必须为每个函数的每个参数组合复制代码的解决方案不感兴趣。

转换构造函数和强制转换运算符似乎都不足以实现这一点。至少我的gcc 4.7.1报告了no matching function call，尽管它确实在一个通知中命名了所需的函数，声明‘point’ is not derived from ‘vec<d>’。

从point到vec<2>的转换没有直接的方法，因为在处理函数调用foo(v1,p1)时，期望vec<2>作为第二个参数的函数foo还不存在。它只是一个函数模板，为了将其实例化为foo(const vec<2> &,const vec<2> &)，必须给出具有这些精确参数类型的函数调用。

为了使代码工作，编译器必须猜测如何实例化模板参数，和要转换为point参数的类型。在一般情况下，这太多了（尽管在特定代码中，它看起来很简单，因为没有其他可能的方法来解释程序员的意图）。

就解决这个问题而言，我唯一能想到的就是创建高度模板化的转换函数：

template <typename T>
struct make_vec
{ };
template <unsigned d>
struct make_vec<vec<d>>
{
  static constexpr unsigned dim = d;
  using type = vec<dim>;
  static const type &from(const type &v)
  { return v; }
};
template <>
struct make_vec<point>
{
  static constexpr unsigned dim = 2;
  using type = vec<dim>;
  static type from(const point &p)
  { return type(p); }
};
template <typename T>
typename make_vec<typename std::decay<T>::type>::type make_vec_from(T&& arg)
{ return make_vec<typename std::decay<T>::type>::from(std::forward<T>(arg)); }

然后实现foo和bar功能作为通用模板（接受所有类型，而不仅仅是vec<d>，使用上面定义的make_vec将给定类型转换为正确类型的vec<d>）：

namespace detail {
  /* Your original implementation of foo. */
  template<unsigned d> vec<d> foo(vec<d>, vec<d>) {
    return vec<d>(/* ... */);
  }
}
/* Templated version of foo that calls the conversion functions (which do
   nothing if the argument is already a vec<d>), and then calls the
   foo() function defined above. */
template <typename T, typename... Ts>
typename make_vec<typename std::decay<T>::type>::type foo(T&& arg, Ts&&... args)
{ return detail::foo(make_vec_from(arg),make_vec_from(args)...); }

在bar的情况下，您还需要一种方法来计算返回类型，即vec<d1+d2+d3...>。为此，需要一个总和计算器，也是模板化的：

template <typename... Ts>
struct dsum {
  static constexpr unsigned value = 0;
};
template <typename T, typename... Ts>
struct dsum<T,Ts...> {
  static constexpr unsigned value = make_vec<typename std::decay<T>::type>::dim + dsum<Ts...>::value;
};

那么，bar()的返回类型为vec<dsum<T,Ts...>::value>。

一个完整的工作示例如下：http://liveworkspace.org/code/nZJYu每年11美元

这并不简单，但如果你真的有很多不同的论点组合，这可能是值得的。

相关文章：