c++lambdac++14variadic

How to create a variadic generic lambda?

Since C++14 we can use generic lambdas:

auto generic_lambda = [] (auto param) {};

This basically means that its call operator is templated based on the parameters marked as auto.

The question is how to create a lambda that can accept a variadic number of parameters similarly to how a variadic function template would work ? If this is not possible what is the closest thing that could be used the same way ? How would you store it ? Is it possible in a std::function ?

Solution

  • Syntax

    How do you create a variadic generic lambda ?

    You can create a variadic generic lambda with the following syntax:

    auto variadic_generic_lambda = [] (auto... param) {};

    Basically you just add ... between auto (possibly ref qualified) and your parameter pack name.

    So typically using universal references would give:

    auto variadic_generic_lambda = [] (auto&&... param) {};

    Usage

    How do you use the parameters ?

    You should consider the variadic generic parameter as having a template parameter pack type, because it is the case. This more or less implies that most if not all usage of those parameters will require templates one way or the other.

    Here is a typical example:

    #include <iostream>

void print(void)
{
}

template <typename First, typename ...Rest>
void print(const First& first, Rest&&... Args)
{
  std::cout << first << std::endl;
  print(Args...);
}

int     main(void)
{
  auto variadic_generic_lambda = [] (auto... param)
    {
      print(param...);
    };

  variadic_generic_lambda(42, "lol", 4.3);
}

    Storage

    How do you store a variadic generic lambda ?

    You can either use auto to store a lambda in a variable of its own type, or you can store it in a std::function but you will only be able to call it with the fixed signature you gave to that std::function :

    auto variadic_generic_lambda = [] (auto... param) {};

std::function<void(int, int)> func = variadic_generic_lambda;

func(42, 42); // Compiles

func("lol"); // Doesn't compile

    What about collections of variadic generic lambdas ?

    Since every lambda has a different type you cannot store their direct type in the usual homogeneous containers of the STL. The way it is done with non generic lambdas is to store them in a corresponding std::function which will have a fixed signature call and that won't restrain anything since your lambda is not generic in the first place and can only be invoked that way:

    auto non_generic_lambda_1 = [] (int, char) {};
auto non_generic_lambda_2 = [] (int, char) {};

std::vector<std::function<void(int, char)>> vec;

vec.push_back(non_generic_lambda_1);
vec.push_back(non_generic_lambda_2);

    As explained in the first part of this storage section if you can restrain yourself to a given fixed call signature then you can do the same with variadic generic lambdas.

    If you can't you will need some form of heterogenous container like:

    See this question for an example of heterogenous container.

    What else ?

    For more general informations on lambdas and for details on the members generated and how to use the parameters within the lambda see: