Spostare tutti gli argomenti di lambda

Question

Voglio creare lambda che accetterà qualsiasi numero di argomenti come:

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

problema qui è che non funziona con il movimento di sola tipi. Se fosse solo 1 arg vorrei fare smth come

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

Come spostare tutti gli args a lambda?

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); 
    }; 
} 

Un po 'icky.

Inserirli in una tupla, quindi decomprimere la tupla con std::apply. Se ti manca std::apply scriviti uno equivalente.

Se si desidera richiamare g con rvalue, rendere esterna lambda mutabile e move tupla interna lambda.

Lambda interno può acquisire per impostazione predefinita & se si desidera accedere a argomenti di esterno o simili.

Possiamo anche astratto questo schema un po ':

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); 
    }; 
} 

uso:

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

Se si desidera che l'elenco di cattura prima, possiamo farlo:

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); 
    }; 
    }; 
} 

uso :

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

che ha il "vantaggio" di avere 3 lambda annidati.

O più divertente:

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.