Können Lambda-Funktionen als Vorlage verwendet werden?

Question

Gibt es in C++11 eine Möglichkeit, eine Lambda-Funktion als Vorlage zu verwenden? Oder ist sie von Natur aus zu spezifisch, um als Vorlage verwendet zu werden?

Ich verstehe, dass ich eine klassische Vorlage Klasse/Functor stattdessen definieren kann, aber die Frage ist mehr wie: erlaubt die Sprache Vorlage Lambda-Funktionen?

Answer 1

Ich frage mich, was es damit auf sich hat:

template <class something>
inline std::function<void()> templateLamda() {
  return [](){ std::cout << something.memberfunc() };
}

Ich habe einen ähnlichen Code wie diesen verwendet, um eine Vorlage zu generieren und frage mich, ob der Compiler die "Wrapping"-Funktion optimieren wird.

Answer 2

Es gibt eine Gcc-Erweiterung die es ermöglicht Lambda-Vorlagen :

// create the widgets and set the label
base::for_each(_widgets, [] <typename Key_T, typename Widget_T>
                         (boost::fusion::pair<Key_T, Widget_T*>& pair) -> void {
                             pair.second = new Widget_T();
                             pair.second->set_label_str(Key_T::label);
                          }
              );

wobei _widgets ist eine std::tuple< fusion::pair<Key_T, Widget_T>... >

Answer 3

Ich habe mit dem neuesten Clang gespielt version 5.0.1 Kompilieren mit dem -std=c++17 Flag und es gibt jetzt eine nette Unterstützung für automatische Typparameter für Lambdas:

#include <iostream>
#include <vector>
#include <stdexcept>

int main() {
    auto slice = [](auto input, int beg, int end) {
        using T = decltype(input);
        const auto size = input.size();
        if (beg > size || end > size || beg < 0 || end < 0) {
            throw std::out_of_range("beg/end must be between [0, input.size())");
        }
        if (beg > end) {
            throw std::invalid_argument("beg must be less than end");
        }
        return T(input.begin() + beg, input.begin() + end);
    };
    auto v = std::vector<int> { 1,2,3,4,5 };
    for (auto e : slice(v, 1, 4)) {
        std::cout << e << " ";
    }
    std::cout << std::endl;
}

Answer 4

Werfen Sie einen Blick auf Boost.Phoenix für polymorphe Lambdas: http://www.boost.org/doc/libs/1_44_0/libs/spirit/phoenix/doc/html/index.html Benötigt übrigens nicht C++0x :)

Answer 5

Ich bin mir nicht sicher, warum niemand sonst dies vorgeschlagen hat, aber Sie können eine Vorlage-Funktion schreiben, die Lambda-Funktionen zurückgibt. Das Folgende löste mein Problem, der Grund, warum ich auf diese Seite kam:

template <typename DATUM>
std::function<double(DATUM)> makeUnweighted() {
  return [](DATUM datum){return 1.0;};
}

Wenn ich nun eine Funktion benötige, die einen bestimmten Typ von Argumenten annimmt (z. B. std::string ), sage ich einfach

auto f = makeUnweighted<std::string>()

und jetzt f("any string") 収益 1.0 .

Das ist ein Beispiel für das, was ich mit "Lambda-Vorlagenfunktion" meine. (Dieser spezielle Fall wird verwendet, um automatisch eine inerte Gewichtungsfunktion bereitzustellen, wenn jemand seine Daten nicht gewichten will, was auch immer seine Daten sein mögen).