How Can I Achieve Move Capture in C Lambdas (C 11 and C 14)?

Move Capture in C 11 Lambda

Generalized Lambda Capture in C 14

C 14 introduces generalized lambda capture, enabling move capture. In C 14, code like the following will be valid:

auto u = make_unique<some_type>( some, parameters ); 

// move the unique_ptr into the lambda
go.run( [ u = move(u) ] { do_something_with( u ); } ); </some_type>

Note that if you need to move the object from the lambda to another function, the lambda must be marked as mutable:

go.run( [ u = move(u) ] mutable { do_something_with( std::move(u) ); } );

Workaround for Move Capture in C 11

In C 11, capturing by move can be achieved using a helper function make_rref that creates an rvalue reference to the desired value:

#include <cassert>
#include <memory>
#include <utility>

template <typename t>
struct rref_impl
{
    rref_impl() = delete;
    rref_impl( T && x ) : x{std::move(x)} {}
    // ... implementation
};

template<typename t> rref_impl<t> make_rref( T && x )
{
    return rref_impl<t>{ std::move(x) };
}</t></t></typename></typename></utility></memory></cassert>

Use the make_rref function to capture the value in the lambda:

int main()
{
    std::unique_ptr<int> p{new int(0)};
    auto rref = make_rref( std::move(p) );
    auto lambda =
        [rref]() mutable -> std::unique_ptr<int> { return rref.move(); };
    assert(  lambda() );
    assert( !lambda() );
}</int></int>

Note that this workaround makes the lambda copyable, which may cause problems when capturing non-copyable objects.

Emulating Generalized Lambda Capture in C 11

Another approach to emulate generalized lambda capture involves defining a capture function:

#include <utility>

template <typename t typename f>
class capture_impl
{
    T x;
    F f;
public:
    // ... implementation
};

template <typename t typename f>
capture_impl<t> capture( T && x, F && f )
{
    return capture_impl<t>(
        std::forward<t>(x), std::forward<f>(f) );
}</f></t></t></t></typename></typename></utility>

Use capture to capture the value by move:

int main()
{
    std::unique_ptr<int> p{new int(0)};
    auto lambda = capture( std::move(p),
        []( std::unique_ptr<int> & p ) { return std::move(p); } );
    assert(  lambda() );
    assert( !lambda() );
}</int></int>

This solution provides a cleaner approach that disables copying the lambda if the captured type is not copyable.

The above is the detailed content of How Can I Achieve Move Capture in C Lambdas (C 11 and C 14)?. For more information, please follow other related articles on the PHP Chinese website!