Transfert parfait dans un lambda?

Question

Avec une fonction, on peut écrire:

template <class T> void f(T&& x) {myfunction(std::forward<T>(x));} 

mais avec un lambda, nous n'avons T:

auto f = [](auto&& x){myfunction(std::forward</*?*/>(x));} 

Comment faire parfait-transfert dans un lambda? Est-ce que decltype(x) fonctionne comme type dans std::forward?

Answer 1

La façon canonique de transmettre un argument lambda qui a été lié à une référence de transfert est en effet avec decltype:

auto f = [](auto&& x){ 
    myfunction(std::forward<decltype(x)>(x)); 
} //      ^^^^^^^^^^^ 

Answer 2

Mon idiome préféré pour cela est:

auto f = [](auto&& x){myfunction(decltype(x)(x));} 

que je lis comme " x comme le type x a été déclaré comme ".

Pour voir comment cela fonctionne, examinez ce qui se passe lorsque x est un int&&. decltype(x)(x) est (int&&)(x), ce qui produit une référence rvalue à x. Si x est un int&, alors nous obtenons (int&)(x) qui est un cast noop à une référence. Rappelez-vous, decltype(x) inclut la catégorie de référence.

Maintenant, pour les paramètres est plus courte, mais auto&& équivalent à:

auto f = [](auto&& x){myfunction(std::forward<decltype(x)>(x));} 

l'alternative.

Pour auto paramètres:

auto f = [](auto x){myfunction(decltype(x)(x));} 

il induit une copie supplémentaire, tandis que

auto f = [](auto x){myfunction(std::forward<decltype(x)>(x));} 

au lieu de se déplace-x.

Alors que je traite habituellement de style C jette comme étant trop dangereux, decltype(x)(x) peut, au pire, faire une copie de type correct de x si x n'est pas une variable auto&&. Et il y a quelque chose à dire pour la brièveté de celui-ci.