我正在尝试编写一个可以转换 vector<T> 的投影函数变成 vector<R> .这是一个例子:

auto v = std::vector<int> {1, 2, 3, 4};
auto r1 = select(v, [](int e){return e*e; }); // {1, 4, 9, 16}
auto r2 = select(v, [](int e){return std::to_string(e); }); // {"1", "2", "3", "4"}

第一次尝试:

template<typename T, typename R>
std::vector<R> select(std::vector<T> const & c, std::function<R(T)> s)
{
   std::vector<R> v;
   std::transform(std::begin(c), std::end(c), std::back_inserter(v), s);
   return v;
}

但是对于

auto r1 = select(v, [](int e){return e*e; });

我明白了:

error C2660: 'select' : function does not take 2 arguments

我必须明确调用 select<int,int>去工作。我不喜欢这样，因为类型是多余的。

auto r1 = select<int, int>(v, [](int e){return e*e; }); // OK

第二次尝试:

template<typename T, typename R, typename Selector>
std::vector<R> select(std::vector<T> const & c, Selector s)
{
   std::vector<R> v;
   std::transform(std::begin(c), std::end(c), std::back_inserter(v), s);
   return v;
}

结果是同样的错误，函数不接受 2 个参数。在这种情况下，我实际上必须提供第三种类型的参数:

auto r1 = select<int, int, std::function<int(int)>>(v, [](int e){return e*e; });

第三次尝试:

template<typename T, typename R, template<typename, typename> class Selector>
std::vector<R> select(std::vector<T> const & c, Selector<T,R> s)
{
   std::vector<R> v;
   std::transform(std::begin(c), std::end(c), std::back_inserter(v), s);
   return v;
}

对于

auto r1 = select<int, int, std::function<int(int)>>(v, [](int e){return e*e; });

错误是:

'select' : invalid template argument for 'Selector', class template expected

对于

auto r1 = select(v, [](int e){return e*e; });

error C2660: 'select' : function does not take 2 arguments

(我知道最后两次尝试不是特别好。)

我该怎么写 select()模板函数适用于我放在开头的示例代码？

最佳答案

选项#1:

基本 decltype()用法:

template <typename T, typename F>
auto select(const std::vector<T>& c, F f)
    -> std::vector<decltype(f(c[0]))>
{
    using R = decltype(f(c[0]));
    std::vector<R> v;
    std::transform(std::begin(c), std::end(c), std::back_inserter(v), f);
    return v;
}

选项 #2:

基本 std::result_of<T>用法:

template <typename T, typename F, typename R = typename std::result_of<F&(T)>::type>
std::vector<R> select(const std::vector<T>& c, F f)
{
    std::vector<R> v;
    std::transform(std::begin(c), std::end(c), std::back_inserter(v), f);
    return v;
}

选项#3:

高级 decltype()用法和完美转发(见注释*):

template <typename T, typename A, typename F>
auto select(const std::vector<T, A>& c, F&& f)
    -> std::vector<typename std::decay<decltype(std::declval<typename std::decay<F>::type&>()(*c.begin()))>::type>
{
    using R = typename std::decay<decltype(std::declval<typename std::decay<F>::type&>()(*c.begin()))>::type;
    std::vector<R> v;
    std::transform(std::begin(c), std::end(c)
                 , std::back_inserter(v)
                 , std::forward<F>(f));
    return v;
}

选项#4:

高级 std::result_of<T>用法和完美转发(见注释*):

template <typename T, typename A, typename F, typename R = typename std::decay<typename std::result_of<typename std::decay<F>::type&(typename std::vector<T, A>::const_reference)>::type>::type>
std::vector<R> select(const std::vector<T, A>& c, F&& f)
{
    std::vector<R> v;
    std::transform(std::begin(c), std::end(c)
                 , std::back_inserter(v)
                 , std::forward<F>(f));
    return v;
}

* 注意: 选项 #3 和 #4 假设 std::transform算法接受一个函数对象按值，然后将其用作非常量左值。这就是为什么人们会看到这个奇怪的 typename std::decay<F>::type&句法。如果函数对象应该在 select 中调用函数本身，并且结果类型不会用作容器的模板参数(出于 outer-most std::decay<T> 的用途)，那么获取正确且可移植的语法返回类型为:

/*#3*/ using R = decltype(std::forward<F>(f)(*c.begin()));

/*#4*/ typename R = typename std::result_of<F&&(typename std::vector<T, A>::const_reference)>::type

关于c++ - 如何从参数列表中推断出函数对象的返回类型？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26383517/