什么时候通过引用在另一个 lambda 中捕获一个 lambda 是安全的？

Question

假设您有以下程序：

static std::function<int(int)> pack_a_lambda( std::function<int(int)> to_be_packed ) {
    return [=]( int value ) {
        return to_be_packed( value * 4 );
    };
}

int main() {
    auto f = pack_a_lambda( []( int value ) {
        return value * 2;
    } );

    int result = f( 2 );

    std::cout << result << std::endl; // should print 16
    return 0;
}

我没有尝试过上面的确切代码，因为我在 Google 测试中测试了它，然后像上面那样稍微编辑了它。因此，函数 pack_a_lambda 将 lambda 按值作为输入。在这里，我相信临时 lambda 被复制了。然后，当我们创建新的 lambda 时，我们再次按值捕获复制的 lambda to_be_packed。它有效，在我看来它应该是安全的。

现在假设我们改为通过引用捕获该 lambda：

static std::function<int(int)> pack_a_lambda( std::function<int(int)> to_be_packed ) {
    return [&]( int value ) {
        return to_be_packed( value * 4 );
    };
}

在我的特定用例中，生成的 lambda 执行速度快四倍。不过，在上面的简化示例中，我无法重现这种差异。事实上，在这里似乎通过引用捕获 lambda 会使它稍微变慢。所以显然存在一些性能差异。

但是安全吗？参数 to_be_packed 被复制了，但它仍然是临时的吧？那应该使它不安全。但我不确定。我的 UB 消毒剂和我的 AddressSanitizer 没有抱怨，但我承认这不能证明任何事情。如果我通过引用传递 to_be_packed...

static std::function<int(int)> pack_a_lambda( const std::function<int(int)> &to_be_packed ) {
    return [&]( int value ) {
        return to_be_packed( value * 4 );
    };
}

... AddressSanitizer 抱怨，这并不奇怪，因为我传递给函数的 lambda 也是临时的。所以剩下示例二：它是否安全，以及在某些情况下执行速度可能更快的可能原因是什么？

Answer 1

When is it safe to capture a lambda inside another lambda by reference?

与任何捕获对象相同：当捕获对象的生命周期长于捕获 lambda 时，它是安全的。

在您的示例中，您捕获了一个函数参数。它的literime在函数returns时结束。但是你 return 将 lambda 捕获到函数的外部。在那里，捕获的引用将无效。

Answer 2

static std::function<int(int)> pack_a_lambda( std::function<int(int)> to_be_packed ) {
    return [&]( int value ) {
        return to_be_packed( value * 4 );
    };
}

是未定义的行为，因为您 "return" 引用了局部变量。按价值是这里安全的方式。

static std::function<int(int)> pack_a_lambda(const std::function<int(int)>& to_be_packed ) {
    return [&]( int value ) {
        return to_be_packed( value * 4 );
    };
}

可能是正确的。您必须确保传递的参数的生命周期长于返回的 std::function.

auto func = std::function([]( int value ) {
        return value * 2;
    });
auto f = pack_a_lambda(func); // OK
// auto f2 = pack_a_lambda([](int){ return 42;}); // KO: temporary std::function created

因为临时可以绑定到 const 引用，在这种情况下，删除右值版本更安全：

static std::function<int(int)> pack_a_lambda(std::function<int(int)>&&) = delete;

什么时候通过引用在另一个 lambda 中捕获一个 lambda 是安全的？

When is it safe to capture a lambda inside another lambda by reference?

c++

lambda

pass-by-reference