Bagaimanakah Saya Boleh Mencapai Move Capture dalam C Lambdas (C 11 dan C 14)?

Move Capture dalam C 11 Lambda

Generalized Lambda Capture dalam C 14

C 14 memperkenalkan generalized lambda capture, mendayakan move capture. Dalam C 14, kod seperti berikut akan sah:

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>

Perhatikan bahawa jika anda perlu mengalihkan objek dari lambda ke fungsi lain, lambda mesti ditandakan sebagai boleh ubah:

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

Penyelesaian untuk Move Capture dalam C 11

Dalam C 11, menangkap melalui gerakan boleh dicapai menggunakan fungsi pembantu make_rref yang mencipta rujukan rnilai kepada nilai yang dikehendaki:

#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>

Gunakan fungsi make_rref untuk menangkap nilai dalam 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>

Perhatikan bahawa penyelesaian ini membuat lambda boleh disalin, yang mungkin menyebabkan masalah apabila menangkap objek yang tidak boleh disalin.

Meniru Tangkapan Lambda Umum dalam C 11

Pendekatan lain untuk meniru tangkapan lambda umum melibatkan penentuan fungsi tangkapan:

#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>

Gunakan tangkapan untuk menangkap nilai dengan bergerak:

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>

Penyelesaian ini menyediakan pendekatan yang lebih bersih yang melumpuhkan penyalinan lambda jika jenis yang ditangkap bukan boleh disalin.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mencapai Move Capture dalam C Lambdas (C 11 dan C 14)?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!