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

【问题标题】：When is it safe to capture a lambda inside another lambda by reference?什么时候通过引用在另一个 lambda 中捕获一个 lambda 是安全的？
【发布时间】：2020-05-22 09:46:53
【问题描述】：

假设你有以下程序：

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 sanitizer 和我的 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 也是临时的。所以剩下的例子二：它是否安全，在某些情况下执行速度更快的可能原因是什么？

【问题讨论】：

注意std::function和lambda是不同的，后者可能可以转换成前者。
感谢您的提醒。因此，我们在 lambda 中捕获了一个 std::function。我的立场是正确的...... :)

标签： c++ lambda pass-by-reference

【解决方案1】：

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

当您“返回”对局部变量的引用时，

是未定义的行为。在这里按价值是安全的方式。

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 引用，在这种情况下，删除 r-value 版本更安全：

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

【讨论】：

【解决方案2】：

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

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

在您的示例中，您捕获了一个函数参数。当函数返回时，它的文本结束。但是您将捕获的 lambda 返回到函数的外部。在那里，捕获的引用将无效。

【讨论】：