c++ - 如何使 C++11 函数采用 function<> 参数自动接受 lambdas

Question

C++11 有 lambda 和 std::function<>，但不幸的是，它们有不同的类型。一个结果是不能直接在高阶函数中使用 lambda，例如 lisp 中的 map。例如，在下面的代码中

 #include <vector>
 #include <functional>
 using namespace std;

 template <typename A,typename B> 
 vector<B> map(std::function<B (A)> f, vector<A> arr) {
       vector<B> res;
       for (int i=0;i<arr.size();i++) res.push_back(f(arr[i]));
       return res;
}

int main () {
    vector<int> a = {1,2,3};
    map([](int x) -> int { return x;},a); //not OK

    auto id_l = [](int x) -> int { return x;};
    map(id_l,a); //not OK;

    function<int (int)> id_f = id_l;
    map(id_f,a); //OK
return 0;
}

，在 main() 的第 2 行中直接使用 lambda 是行不通的。 g++ -std=c++11 testfunc.cpp返回 `... testfunc.cpp:14:37: 注意:'main()::__lambda0' 不是从 'std::function' 派生的。

C++11 类型推断也失败了，你可以看到如果将 lambda 存储到自动变量然后使用它，类型信息仍然丢失，可能是由于类型删除和性能损失小的原因(正如我被告知的那样:why do lambda functions in c++11 not have function<> types?)。

有效的方法是将 lambda 存储在 std:function<> 类型的变量中并使用该变量。这相当不方便，并且有点违背在 C++11 的函数式编程中使用 lambda 的目的。例如，不能用 bind 或 flip 之类的东西就地操纵 lambda，而是必须先将 lambda 存储到一个变量。

我的问题是，是否有可能(以及如何)克服这个问题并使 main() 的第 2 行合法，例如通过覆盖一些类型转换运算符？ (当然，这意味着我不关心使用/不使用类型删除所涉及的小性能损失。)

提前致谢。

--- 编辑 ---

澄清一下，我使用 std::function 的原因std::function 而不是函数参数的泛型类型参数具有准确的类型信息，而泛型类型参数如 template <typename F> map(F f, ...)不包含类型信息。另外，正如我最终发现的那样，每个 lambda 都是它自己的类型。因此，类型删除甚至不是 lambda 与其匹配 std::function 之间不兼容的问题。对象。

---更新---

关于如何使上面的 map 功能起作用或如何改进它们，已经有两个答案。只是为了澄清。我的问题不是关于如何使 map 工作。还有很多其他用例涉及使用 std::function<> 类型参数，我认为这至少可以使代码更具可读性并使类型推断变得容易。到目前为止的答案是关于如何不使用 std::function<> 作为参数。我的问题是关于如何使这样的函数(使用 std::function<> 类型参数)自动接受 lambda。

-- 更新 2 ---

作为对评论的回应，这里有一个实际案例示例，其中 std::function<> 中的类型信息可能会有用。假设我们要实现 fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b 的 C++ 等效项在 OCaml ( http://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html ) 中。

有了 std::function<>，就可以做到

 //approach#1
 template <typename A,typename B> 
 B fold_right(std::function<B (A, B)> f, vector<A> arr, B b) {
     ...
 }

从上面可以清楚的看出什么f是什么，它能承受什么，不能承受什么。也许，也可以用

 //approach#2
 template <typename A,typename B, typename F> 
 auto fold_right2(F f, vector<A> arr, B b) -> decltype(f(???)) {
      ...
 }

但是，当您试图找出要放入 decltype 中的内容时，这会变得有点丑陋。 .另外，f 到底是什么？服用，正确的使用方法是什么f ？从可读性的角度来看，我猜代码的读者只能通过解释函数体中的实现来弄清楚什么是 f(函数或标量)和 f 的签名。

这是我不喜欢的，也是我的问题的来源。如何使方法#1 方便地工作。例如，如果 f表示两个数字相加，如果您先创建一个函数对象，则方法#1 有效:

std::function<int (int, int)> add = [](int x, int y) -> int { return x + y; }
fold_right(add,{1,2,3},0);

撇开效率问题不谈，上面的代码很不方便，因为 std::function 不能接受 lambda。所以，

fold_right([](int x, int y) -> int { return x + y; },{1,2,3},0);

目前在 C++11 中不起作用。我的问题具体是关于是否有可能制作像 fold_right 这样的功能上面定义的直接接受 lambda。也许期望太高了。我希望这能澄清问题。

Answer 1

为什么要通过 std::function<...> 创建动态间接寻址首先？只需对函数对象进行模板化，您就可以排序:

template <typename A, typename F> 
auto map(F f, std::vector<A> arr) -> std::vector<decltype(f(arr[0]))> {
    std::vector<decltype(f(arr[0]))> res;
    for (int i=0; i<arr.size(); ++i)
        res.push_back(f(arr[i]));
    return res;
}

事实上，也没有必要确定容器类型，您可能希望通过 [ const 传递它。 ] 引用资料:

template <typename C, typename F> 
auto map(F f, C const& c) -> std::vector<decltype(f(*c.begin()))> {
    std::vector<decltype(f(*c.begin()))> res;
    for (auto const& value: c)
        res.push_back(f(value));
    return res;
}

最后，请注意标准 C++ 库中已经有一个“映射”函数。它恰好拼写为std::transform()并且有一个接口(interface)更适合 C++ 中的通用方法:

std::vector<int> result;
std::transform(a.begin(), a.end(), std::back_inserter(result),
               [](int x){ return x;});