在C ++ 11中对lambda进行内存管理

Question

有人可以描述为什么这段代码不起作用（在从调用返回之前的GCC4.7.3 seg-faults上）？

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

template<typename F>
auto memo(const F &x) -> std::function<decltype(x())()> {
    typedef decltype(x()) return_type;
    typedef std::function<return_type()> thunk_type;
    std::shared_ptr<thunk_type> thunk_ptr = std::make_shared<thunk_type>();

    *thunk_ptr = [thunk_ptr, &x]() {
        cerr << "First " << thunk_ptr.get() << endl;
        auto val = x();
        *thunk_ptr = [val]() { return val; };
        return (*thunk_ptr)();
    };

    return [thunk_ptr]() { return (*thunk_ptr)(); };
};

int foo() {
    cerr << "Hi" << endl;
    return 42;
}

int main() {
    auto x = memo(foo);
    cout << x() << endl ;
    cout << x() << endl ;
    cout << x() << endl ;
};

我原来的假设：

1. 每个std::function<T()>都是对某个表示闭包的对象的引用/ shared_ptr。 即捡货价值的生命时间受到限制。
2. std::function<T()>对象具有赋值运算符，该运算符将放弃旧的闭包（结束生命周期选择的值）并将获得新值的所有权。

PS我在阅读关于C ++ 11中懒惰的问题后提出了这个问题

Answer 1

这是有问题的代码：

[thunk_ptr, &x]() {
    auto val = x();
    *thunk_ptr = [val]() { return val; };
    return (*thunk_ptr)(); // <--- references a non-existant local variable
}

问题是本地thunk_ptr是来自上下文的副本。 也就是说，在赋值*thunk_ptr = ... ， thunk_ptr指的是函数对象拥有的副本。 但是，通过赋值，函数对象不再存在。 也就是说，在下一行thunk_ptr引用刚刚被破坏的对象。

有几种方法可以解决这个问题：

1. 不要变得花哨，只需返回val 。 这里的问题是return_type可能是一个引用此方法失败的引用类型。

2. 直接从赋值返回结果：在赋值之前thunk_ptr仍然存在并且在赋值之后它仍然返回对std::function<...>()对象的引用：

    return (*thunk_ptr = [val](){ return val; })(); 

3. 安全thunk_ptr的副本并使用此副本在return语句中调用函数对象：

    std::shared_ptr<thunk_type> tmp = thunk_ptr; *tmp = [val]() { return val; }; return (*tmp)(); 

4. 保存std::function的引用副本并使用它而不是引用属于覆盖闭包的字段：

    auto &thunk = *thunk_ptr; thunk = [val]() { return val; }; return thunk();