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
?
Conceptually, a generic lambda is equivalent to a function object with a templatized function-call operator method: struct LambdaClosureType { ... template<template-params> ret operator()(params) const { ... } .... };
Creating a Lambda Expression in C++auto greet = []() { // lambda function body }; Here, [] is called the lambda introducer which denotes the start of the lambda expression. () is called the parameter list which is similar to the () operator of a normal function.
Variadic templates are class or function templates, that can take any variable(zero or more) number of arguments. In C++, templates can have a fixed number of parameters only that have to be specified at the time of declaration. However, variadic templates help to overcome this issue.
Calls of the lambda are translated to direct calls to its operator() and can therefore be inlined.
I am not sure what your intention is but instead of storing it in a std::function
you can use the lambda itself to capture the params. This is an example discussed on the boost mailing list. It is used in the boost::hana implementation
auto list = [](auto ...xs) { return [=](auto access) { return access(xs...); }; }; auto head = [](auto xs) { return xs([](auto first, auto ...rest) { return first; }); }; auto tail = [](auto xs) { return xs([](auto first, auto ...rest) { return list(rest...); }); }; auto length = [](auto xs) { return xs([](auto ...z) { return sizeof...(z); }); }; // etc... // then use it like auto three = length(list(1, '2', "3"));
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) {};
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); }
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:
std::vector<boost::variant>
std::vector<boost::any>
boost::fusion::vector
See this question for an example of heterogenous container.
For more general informations on lambdas and for details on the members generated and how to use the parameters within the lambda see:
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With