根据传递的函子约束模板参数

Question

我想根据传递的函子来约束模板参数。考虑这个来自某些容器类型的FoldLeft 函数：

template<typename F, typename R>
R FoldLeft(F&& functor, R initialValue) {
    R r = initialValue;
    /* assume that this is a range of uint64_t's */
    while (first != last) {
        r = std::forward<F>(functor)(r, *(first++));
    }
    return r;
}

这个函数可以这样调用：

auto sum = FoldLeft([](uint64_t i, auto& e) { return e + i; }, 0);

这里的问题是R 是从initialValue 参数推导出来的，在这种情况下是0，因此导致int。同样decltype(sum) 也给出int。

我想将R 推导出为函子的返回类型，它可以是 lambda 或任何其他可调用类型。我已经尝试过使用this answer的方法，但总是遇到这个错误：

error:  decltype cannot resolve address of overloaded function
struct function_traits
       ^~~~~~~~~~~~~~~
note:   substitution of deduced template arguments resulted in errors seen above

我尝试的代码（fuction_traits 复制自链接答案）：

template<typename T>
using LamRet = typename function_traits<T>::result_type;

template<typename F>
LamRet<F> FoldLeft(F&& functor, LamRet<F> initialValue) {
    LamRet<F> r = initialValue;
    /* assume that this is a range of uint64_t's */
    while (first != last) {
        r = std::forward<F>(functor)(r, *(first++));
    }
    return r;
}

Answer 1

Function traits 所描述的，根据我的经验，几乎没用，并且使用它们会像这样绑定，因为 C++ 中的可调用对象没有像函数特征那样声称的特征。

（一个大的例外是您几乎在使用特定于问题的子语言并有意与特征合作以便调用 DRY 而不必在两个位置重复类型）。

只有一部分可调用对象才具有此类特征。而且，您编写的 C++14 和 C++17 样式 lambda 越多，符合条件的可调用对象就越少。

确定返回值，你需要知道你迭代的类型是什么。然后检查decltype( lambda( argument, iterated_type ) )（也可以写成result_of_t或invoke_result_t模板类型）。

假设你的迭代类型是T，你的参数是A：

template<class F, class A>
using LamRet = std::decay_t<std::result_of_t<F&&( A&&, T& )>>;

然后我们可以检查我们的 lambda 参数类型：

template<class F, class A>
using LamArgGood = std::is_convertible< A&&, LamRet<F, A> >;

和

template<class F, class A>
using LamRetGood = std::is_convertible< LamRet<F, A>, LamRet< F, LamRet<F, A > >;

确保迭代的返回类型有效。

template<class F, class A,
  class dA = std::decay_t<A>,
  std::enable_if_t< LamArgGood<F, dA>{} && LamRetGood<F, dA>{}, bool> =true
>
LamRet<F, dA> FoldLeft(F&& functor, A&& initialValue) {
  LamRet<F, dA> r = std::forward<A>(initialValue);
  /* assume that this is a range of uint64_t's */
  while (first != last) {
    r = std::forward<F>(functor)(r, *(first++));
  }
  return r;
}

这不太对，但会捕获 99% 的类型错误。 （我在迭代中分配，而不是构造；我从A&& 转换为LamRet，而不是dA&&）。