Understanding Move Capture in C Lambdas

In C 11, capturing variables in lambdas is generally done by reference. This reference remains alive as long as the lambda exists, which can sometimes lead to unintended behavior if the captured variable is moved out.

A C 14 Solution: Generalized Lambda Capture

In C 14, generalized lambda capture was introduced, allowing for move capture. This enables convenient manipulation of move-only types, such as unique pointers.

std::make_unique()
    .then([u = std::move(u)] { do_something_with(u); });

Workarounds for C 11

Prior to C 14, move capture can be emulated using helper functions:

Method 1: make_rref

This approach creates a wrapper class, rref_impl, that encapsulates the value and manages its lifetime.

template  using rref_impl = ...;
auto rref = make_rref(std::move(val));

[rref]() mutable { std::move(rref.get()); };

However, capturing rref in a lambda allows it to be copied, potentially leading to runtime errors.

Method 2: capture() Function

This method uses a function that takes the captured value by reference and returns a lambda that calls the function with the captured value as an argument.

template  using capture_impl = ...;
auto lambda = capture(std::move(val), [](auto&& v) { return std::forward(v); });

This prevents copying the lambda and ensures that the captured value is moved into the lambda's scope.

Remember, these workarounds are not as elegant as the generalized lambda capture in C 14, but they provide a way to emulate move capture in earlier versions of the language.