Cattura lambda generalizzata su param-pack?

Question

In C++ 14, cattura lambda generalizzata facciamolo:

template<class T> 
auto pack(T t) 
{ 
    return [t=std::move(t)](auto&& f){f(t);}; 
}; 

Ma non gioca con param-pack:

template<class... T> 
auto pack(T... t) 
{ 
    return [t=std::move(t)...](auto&& f){f(t...);}; 
}; 

C'è una sintassi speciale o proposta più standard affrontare questo?

Answer 1

Il mio progetto di C++ 14 dice ([expr.prim.lambda]/24):

A semplice-capture seguito da puntini di sospensione è un pacchetto di espansione (14.5.3). Un init-capture seguito da un'ellissi è mal formato.

Quindi sembra che non ci sia modo di fare una cattura generalizzata variadica. Una possibile soluzione è quella di catturare solo gli argomenti in una tupla e quindi utilizzare una delle soluzioni proposte qui: "unpacking" a tuple to call a matching function pointer

auto pack(T... t) 
{ 
    return [args=make_tuple(std::move(t)...)](auto&& f){ 
       // find a way to call f with args 
      }; 
}; 

Answer 2

Come follow-up, sono arrivato a questa soluzione:

template<class T> 
struct mover 
{ 
    mover(T const& val) : val(val) {} 

    mover(T&& val) : val(std::move(val)) {} 

    mover(mover const& other) = default; 

    mover(mover&& other) = default; 

    mover(mover& other) : val(std::move(other.val)) {} 

    operator T const&() const 
    { 
     return val; 
    } 

    T val; 
}; 

template<class T> 
using wrap_t = typename std::conditional 
    < 
     std::is_move_constructible<T>::value 
    && !std::is_trivially_copy_constructible<T>::value 
     , mover<T> 
     , T 
    >::type; 

template<class... Ts> 
auto pack_impl(wrap_t<Ts>... ts) 
{ 
    return [=](auto&& f)->decltype(auto) 
    { 
     return f(static_cast<Ts const&>(ts)...); 
    }; 
} 

auto pack = [](auto&&... ts) 
{ 
    return pack_impl<std::decay_t<decltype(ts)>...>(static_cast<decltype(ts)>(ts)...); 
}; 

E ' utilizza mover come proxy, che consente a lambda di acquisirlo tramite move (è un po 'hacky). E wrap_t decide quando è necessario o utile applicare mover.

Ora possiamo testarlo:

struct A 
{ 
    A() = default; 

    A(A&&) 
    { 
     std::cout << "move\n"; 
    } 

    A(A const&) 
    { 
     std::cout << "copy\n"; 
    } 
}; 

A a; 
std::cout <<"p1------------\n"; 
auto p1 = pack(std::move(a)); 
std::cout <<"p2------------\n"; 
auto p2 = std::move(p1); 
std::cout <<"p3------------\n"; 
auto p3 = p2; 

stamperà:

p1------------ 
move 
move 
p2------------ 
move 
p3------------ 
copy 

Answer 3

Questo si espande su mio commento a Brian risposta di cui sopra. In C++ 14 con i fondamenti della biblioteca TS è possibile:

template<class... T> 
auto pack(T... t) 
{ 
    return [ts = std::make_tuple(std::move(t)...)](auto&& f){ 
     std::experimental::apply(f, ts); 
    }; 
}; 

Supponendo che si desidera catturare genericamente un parametro pack mossa e utilizzarlo all'interno di un lambda è possibile scrivere il codice in un lambda all'interno di un lambda, e quindi applicare gli argomenti su di esso:

[ts = std::make_tuple(std::move(t)...)](/* args */){ 
    auto lambda = [&](auto&&... args) { 
     // - args is the original parameter pack that one wanted to 
     // capture by move 
     // - the other arguments can be used by reference 
    }; 
    return std::experimental::apply(lambda, ts); 
};