So erstellen Sie eine Variable generische lambda?

Da C++14 wir können generische lambdas:

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

Dies bedeutet im Grunde, dass seine call-operator Vorlagen basierend auf den Parametern, die mit auto markiert.

Die Frage ist, wie man eine lambda akzeptieren kann, eine Variable Anzahl von Parametern, die ähnlich wie eine Variable Funktion Vorlage funktionieren würde ? Wenn dies nicht möglich ist, was ist die nächste Sache, die verwendet werden könnten, den gleichen Weg ?
Wie würden Sie es speichern ? Ist es möglich in einem std::function ?

InformationsquelleAutor der Frage Drax | 2014-09-17

c++c++14 lambda variadic

Ich bin nicht sicher, was deine Absicht ist, aber anstatt es zu speichern in einer std::function können Sie mithilfe der lambda-Ausdruck selbst zu erfassen, den params.
Dies ist ein Beispiel diskutiert, auf den boost-mailing-Liste. Es wird in den boost::hana Umsetzung

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"));

InformationsquelleAutor der Antwort mkaes

25

Syntax

Wie erstellen Sie eine Variable generische lambda ?

Können Sie erstellen eine Variable generische lambda-Ausdruck mit der folgenden syntax:
```
auto variadic_generic_lambda = [] (auto... param) {};
```
Im Grunde fügen Sie einfach ... zwischen auto (möglicherweise ref qualifiziert) und Ihre parameter pack Namen.

So, in der Regel mit universal-Verweise geben würde:
```
auto variadic_generic_lambda = [] (auto&&... param) {};
```
Nutzung

Wie verwenden Sie das Parameter ?

Sollten Sie die Variable generische parameter eine template parameter pack geben, da es der Fall ist. Diese mehr oder weniger impliziert, dass die meisten, wenn nicht alle Verwendung dieser Parameter erfordert templates die eine oder andere Weise.

Hier ist ein typisches Beispiel:
```
#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);
}
```
Lagerung

Wie Sie speichern eine Variable generische lambda ?

Können Sie entweder auto zu speichern, einen lambda-Ausdruck in eine variable des eigenen Typs, oder Sie können speichern Sie es in einem std::function aber Sie werden nur in der Lage sein, es zu nennen mit der festen Unterschrift Gaben Sie an, dass 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
```
Was ist mit Sammlungen von variadischen generische lambdas ?

Da jeder lambda-Ausdruck hat eine andere Art können Sie speichern Ihre direkte Art in der üblichen homogenen Containern der STL. Die Art und Weise ist es getan mit nicht generischen lambdas ist, speichern Sie in einem entsprechenden std::function die haben eine Feste Signatur zu rufen und nicht zurückhalten nichts, da dein lambda ist nicht generisch in den ersten Platz, und kann nur geltend gemacht werden, die Art und Weise:
```
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);
```
Wie schon im ersten Teil dieser Lagerung Abschnitt, wenn Sie können, beschränken sich auf einen bestimmten Anruf Signatur, dann können Sie das gleiche tun mit variadischen generische lambdas.

Wenn Sie können nicht, Sie müssen in irgendeiner form der heterogenen container wie:
- std::vector<boost::variant>
- std::vector<boost::any>
- boost::fusion::vector
Sehen diese Frage ein Beispiel für eine heterogene container.

Was anderes ?

Weitere Allgemeine Informationen auf lambdas und für details auf die Mitglieder erzeugt wird und wie die Parameter in der lambda-Ausdruck finden Sie unter:
InformationsquelleAutor der Antwort Drax

Betrachten Sie diese

#include <iostream>

    namespace {

        auto out_ = [] ( const auto & val_) 
        {
            std::cout << val_;
            return out_ ;
        };

        auto print = [](auto first_param, auto... params)
        {
            out_(first_param);

            //if there are  more params
            if constexpr (sizeof...(params) > 0) {
                //recurse
                print(params...);
            }
                return print;
        };
    }

int main()
{
    print("Hello ")("from ")("GCC ")(__VERSION__)(" !"); 
}

(wandbox hier) Diese "print" lambda:

Variadic
Rekursive
Generic
Schnell

Und keine Vorlage in Sicht. (einfach drunter 🙂 ) Kein C++ - code, der aussieht wie radio-Rauschen. Einfache, saubere und vor allem:

Syntax

Nutzung

Lagerung

Was anderes ?