具有动态存储持续时间的 Lambda

Question

根据 cppreference.com，C++11 lambda 字面量语法仅在 direct initialization 中使用是合法的。似乎没有办法直接将 lambda 语法与 new 运算符一起使用。

我需要在堆中存储一个 lambda 函数，以便以后可以从不同的线程调用它。制作 lambda 的副本很容易，但是有没有一种简单的方法可以直接在堆中分配 lambda（动态存储持续时间），而无需先在堆栈上分配它（自动存储持续时间）并制作副本？

这是一个简单的例子：

#include <cstdio>
#include <cassert>

struct MyObj {
    int value;
    int copies;
    int moves;

    MyObj(int v): value(v), copies(0), moves(0) {
        printf("Created object with value %d.\n", value);
    }

    MyObj(const MyObj &other): value(other.value),
    copies(other.copies+1), moves(other.moves) { }

    MyObj(const MyObj &&other): value(other.value),
    copies(other.copies), moves(other.moves+1) { }
};

int main (int argc, char **argv) {
    MyObj o { 5 };
    // Create lambda on stack (automatic storage duration)
    auto f = [o] {
        printf("Object value is %d\n", o.value);
        printf("%d copies, %d moves...\n", o.copies, o.moves);
    };
    // Copy lambda to heap (dynamic storage duration)
    decltype(f) *g = new decltype(f)(f);
    // Call the copy
    (*g)();
    return 0;
}

上述程序制作了o 的2 个副本（一个在捕获中，另一个在将lambda 复制到堆中时）。理想情况下，只有一个副本或移动，当堆分配的 lambda 捕获 o 的副本时会发生这种情况。

Answer 1

在 C++11 中，lambda 表达式将总是产生某种形式的自动对象，无论是堆栈变量还是未命名的临时对象。你无法改变这一点。

在 C++17 中，保证省略使我们能够做到这一点：

new auto(<lambda>)

这使用new 分配的内存来存储该表达式的结果。这里不会创建临时 lambda 对象，也不会调用 lambda 的任何复制/移动构造函数。最重要的是，该语言不要求 lambda 类型具有可以调用的复制/移动构造函数。

您需要保证省略以确保这一点。如果没有该保证，那么您将依靠编译器对其进行优化。标准允许这种情况下省略副本。是的，任何值得使用的编译器都可能会忽略这些副本。

通过保证省略，您可以捕获固定类型，并且这仍然可以在不复制任何内容的情况下工作。在 C++17 之前，您的 lambda 仍然需要有一个复制或移动构造函数，即使对它的调用被省略了。

Answer 2

auto 关键字在 new 表达式中是合法的，这允许您这样做：

    // Create lambda directly in heap (dynamic storage duration)
    auto g = new auto([o] {
        printf("Object value is %d\n", o.value);
        printf("%d copies, %d moves...\n", o.copies, o.moves);
    });

这是整个（更新的）示例：

#include <cstdio>
#include <cassert>

struct MyObj {
    int value;
    int copies;
    int moves;

    MyObj(int v): value(v), copies(0), moves(0) {
        printf("Created object with value %d.\n", value);
    }

    MyObj(const MyObj &other): value(other.value),
    copies(other.copies+1), moves(other.moves) { }

    MyObj(const MyObj &&other): value(other.value),
    copies(other.copies), moves(other.moves+1) { }
};

int main (int argc, char **argv) {
    MyObj o { 5 };
    // Create lambda directly in heap (dynamic storage duration)
    auto g = new auto([o] {
        printf("Object value is %d\n", o.value);
        printf("%d copies, %d moves...\n", o.copies, o.moves);
    });
    // Call heap lambda
    (*g)();
    return 0;
}

以上内容仅根据需要制作了o 的一份副本——至少在我的平台上（Apple LLVM 版本 7.0.0 (clang-700.1.76)）。

Answer 3

您可以考虑使用 std::make_unique 之类的东西：

template <typename Lambda>
std::unique_ptr<Lambda> make_unique_lambda(Lambda&& lambda)
{
    return std::unique_ptr<Lambda>(
        new Lambda(std::forward<Lambda>(lambda))
    );
}

auto unique_lambda = make_unique_lambda([] () {
    // ...
});

Answer 4

可以跨线程移动的多态函数容器是 std::function，它可以由 lambda 直接初始化。

int main (int argc, char **argv) {
    std::function<void()> g = [o = MyObj{5}]{
        printf("Object value is %d\n", o.value);
        printf("%d copies, %d moves...\n", o.copies, o.moves);
    };

    // Call the copy
    g();

    // now *move* it to another thread and call it there

    std::thread t([my_g = std::move(g)] { my_g(); });
    t.join();
    return 0;
}

预期：

Created object with value 5.
Object value is 5
0 copies, 1 moves...
Object value is 5
0 copies, 1 moves...