alle Argumente auf Lambda

Question

Ich möchte Lambda erstellen, die eine beliebige Anzahl von Argumenten wie akzeptieren:

template <typename... Args> 
void f(Args... args) { 
    auto l = [args...]() { 
     g(args...); 
    } 
    // use l 
} 

Problem hier ist, dass es nicht mit Einzug nur Typen funktioniert. Wenn es nur ein arg war, würde ich smth wie

void f(Arg arg) { 
    auto l = [arg = std::move(arg)]() { 
     g(move(arg)); 
    } 
} 

Wie alle args Lambda bewegen?

Answer 1

template <class... Args> 
void f(Args... args) { 
    auto l = [tup=std::make_tuple(std::move(args)...)] { 
    std::apply([](auto&&...args){ 
     g(decltype(args)(args)...); 
    }, tup); 
    }; 
} 

Ein bisschen icky.

Packen Sie sie in ein Tupel, dann entpacken Sie Tupel mit . Wenn Sie keine haben, schreiben Sie sich eine gleichwertige.

Wenn Sie g mit rvalues ​​aufrufen möchten, machen Sie äußere Lambda-Mutable und move Tuple in innere Lambda.

Inner Lambda kann standardmäßig & erfassen, wenn Sie Zugriff auf Args von außen oder dergleichen möchten.

Wir können auch abstrakt dieses Muster ein bisschen:

template<class F, class...Args> 
auto forward_capture(F&& f, Args&&...args) { 
    return [ 
    f=std::forward<F>(f), 
    tup=std::make_tuple(std::forward<Args>(args)...) 
    ]{ 
    return std::apply(f, tup); 
    }; 
} 

Verwendung:

template <typename... Args> 
void f(Args... args) { 
    auto l = forward_capture(
    [](auto&&...args) { 
     g(args...); 
    }, 
    std::move(args)... 
); 
    // use l 
} 

Wenn Sie die Aufnahmeliste zuerst wollen, können wir es tun:

template<class...Args> 
auto forward_capture(Args&&...args) { 
    return [ 
    tup=std::make_tuple(std::forward<Args>(args)...) 
    ](auto&& f)mutable{ 
    return [ 
     f=decltype(f)(f), 
     tup=std::move(tup) 
    ]{ 
     return std::apply(f, tup); 
    }; 
    }; 
} 

Einsatz :

template <typename... Args> 
void f(Args... args) { 
    auto l = forward_capture(std::move(args)...)(
    [](auto&&...args) { 
     g(args...); 
    } 
); 
    // use l 
} 

die den "Vorteil" hat, dass wir 3 verschachtelte Lambdas haben.

oder mehr Spaß:

template<class...Args> 
struct arrow_star { 
    std::tuple<Args...> args; 
    template<class F> 
    auto operator->*(F&& f)&& { 
     return [f=std::forward<F>(f),args=std::move(args)]()mutable{ 
     return std::experimental::apply(std::move(f), std::move(args)); 
     }; 
    } 
}; 
template<class...Args> 
arrow_star<std::decay_t<Args>...> forward_capture(Args&&...args) { 
    return {std::make_tuple(std::forward<Args>(args)...)}; 
} 
template<class...Args> 
auto f(Args... args) 
{ 
    return 
    forward_capture(std::move(args)...) 
    ->* 
    [](auto&&...args){ 
     g(decltype(args)(args)...); 
    }; 
} 

live example.