Perfect forwaring of auto&& in generic lambda

by

In C++20 and later

auto lambda20 = []<class F, class...Ts>(F &&fn, Ts &&...args) {
    return std::forward<F>(fn)(std::forward<Ts>(args)...);
};

In C++pre20 : C++11,14,17

auto lambda14 = [](auto &&fn, auto &&...args) {
    return std::forward<
            std::conditional_t<
                    std::is_rvalue_reference_v<decltype(fn)>,
                    typename std::remove_reference_t<decltype(fn)>,
                    decltype(fn)>
    >(fn)(
            std::forward<
                    std::conditional_t<std::is_rvalue_reference<decltype(args)>::value,
                            typename std::remove_reference<decltype(args)>::type,
                            decltype(args)
                    >>(args)...);
};

Example

#include <iostream>
using namespace std;
int main() {
    auto lambda20 = []<class F, class...Ts>(F &&fn, Ts &&...args) {
        return std::forward<F>(fn)(std::forward<Ts>(args)...);
    };
    auto lambda14 = [](auto &&fn, auto &&...args) {
        return std::forward<
                std::conditional_t<
                        std::is_rvalue_reference_v<decltype(fn)>,
                        typename std::remove_reference_t<decltype(fn)>,
                        decltype(fn)>
        >(fn)(
                std::forward<
                        std::conditional_t<std::is_rvalue_reference<decltype(args)>::value,
                                typename std::remove_reference<decltype(args)>::type,
                                decltype(args)
                        >>(args)...);
    };
    int inter = 20;
    lambda20([](int x) { cout << "asdf20   x" << endl; }, inter);
    lambda20([](int &x) { cout << "asdf20  &x" << endl; }, inter);
    lambda20([](int &&x) { cout << "asdf20 &&x" << endl; }, std::move(inter));
    lambda14([](int x) { cout << "asdf14   x" << endl; }, inter);
    lambda14([](int &x) { cout << "asdf14  &x" << endl; }, inter);
    lambda14([](int &&x) { cout << "asdf14 &&x" << endl; }, std::move(inter));

    return 0;
}

C++ pre-20 solution 8 years old by Scott Meyers https://scottmeyers.blogspot.com/2013/05/c14-lambdas-and-perfect-forwarding.html

More Related Contents:

  1. Capturing perfectly-forwarded variable in lambda
  2. Purpose of perfect forwarding for Callable argument in invocation expression?
  3. What is a lambda expression in C++11?
  4. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  5. C++11 does not deduce type when std::function or lambda functions are involved
  6. How to create an std::function from a move-capturing lambda expression?
  7. How to capture a unique_ptr into a lambda expression?
  8. Resolving ambiguous overload on function pointer and std::function for a lambda using + (unary plus)
  9. trailing return type using decltype with a variadic template function
  10. Is constexpr supported with lambda functions / expressions?
  11. The simplest and neatest c++11 ScopeGuard
  12. Using member variable in lambda capture list inside a member function
  13. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  14. Inferring the call signature of a lambda or arbitrary callable for “make_function”
  15. Can I typically/always use std::forward instead of std::move?
  16. Function returning a lambda expression
  17. What does the void() in decltype(void()) mean exactly?
  18. C++11 “overloaded lambda” with variadic template and variable capture
  19. Can lambda functions be recursive? [duplicate]
  20. What is the lifetime of a C++ lambda expression?
  21. Why do lambda functions drop deduced return type reference by default?
  22. Are lambdas inlined like functions in C++?
  23. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  24. C++11 Change `auto` Lambda to a different Lambda?
  25. how to specify vc11 lambda calling convention
  26. Why does std::forward have two overloads?
  27. Proper way to receive a lambda as parameter by reference
  28. When to use functors over lambdas
  29. Why can’t C++11 move a noncopyable functor to a std::function?
  30. Using Boost adaptors with C++11 lambdas

Leave a Comment