Можно ли использовать шаблоны лямбда-функций?

ОБНОВЛЕНИЕ 2018: C ++ 20 будет содержать шаблонные и концептуальные лямбды. Эта функция уже интегрирована в стандартный проект.

ОБНОВЛЕНИЕ 2014: C ++ 14 был выпущен в этом году и теперь предоставляет полиморфные лямбды с тем же синтаксисом, что и в этом примере. Некоторые крупные компиляторы уже реализуют это.

На нем стоит (в C ++ 11), к сожалению, нет. Полиморфные лямбды были бы превосходны с точки зрения гибкости и мощности.

Первоначальная причина того, что они оказались мономорфными, заключалась в концепциях. Концепции усложнили эту ситуацию с кодом:

template <Constraint T>
void foo(T x)
{
    auto bar = [](auto x){}; // imaginary syntax
}

В ограниченном шаблоне вы можете вызывать только другие ограниченные шаблоны. (В противном случае ограничения нельзя было бы проверить.) Может ли foo вызвать bar(x)? Какие ограничения есть у лямбда (в конце концов, параметр для него - всего лишь шаблон)?

Концепции не были готовы заниматься такими вещами; для этого потребовалось бы еще кое-что вроде late_check (где концепция не проверялась до вызова) и прочее. Проще было просто отказаться от всего этого и придерживаться мономорфных лямбд.

Однако с удалением концепций из C ++ 0x полиморфные лямбды снова стали простым предложением. Однако предложений по нему я не нашел. :(

Лямбда-выражения С ++ 11 не могут быть шаблонными, как указано в других ответах, но decltype(), похоже, помогает при использовании лямбда-выражения в шаблонном классе или функции.

#include <iostream>
#include <string>

using namespace std;

template<typename T>
void boring_template_fn(T t){
    auto identity = [](decltype(t) t){ return t;};
    std::cout << identity(t) << std::endl;
}

int main(int argc, char *argv[]) {
    std::string s("My string");
    boring_template_fn(s);
    boring_template_fn(1024);
    boring_template_fn(true);
}

Печать:

My string
1024
1

Я обнаружил, что этот метод помогает при работе с шаблонным кодом, но я понимаю, что это по-прежнему означает, что сами лямбды не могут быть шаблонными.

В C ++ 11 лямбда-функции нельзя создавать по шаблонам, но в следующей версии стандарта ISO C ++ (часто называемого C ++ 14) эта функция будет представлена. [Источник]

Пример использования:

auto get_container_size = [] (auto container) { return container.size(); };

Обратите внимание, что хотя в синтаксисе используется ключевое слово auto, при выводе типа не используются правила вывода типа auto, а вместо этого используются правила вывода аргумента шаблона. Также см. предложение для общих лямбда-выражений (и обновить до этого).

В C ++ 20 это возможно с использованием следующего синтаксиса:

auto lambda = []<typename T>(T t){
    // do something
};

Мне известно, что этот вопрос касается C ++ 11. Однако для тех, кто погуглил и попал на эту страницу, шаблонные лямбды теперь поддерживаются в C ++ 14 и носят название Generic Lambdas.

[info] Большинство популярных компиляторов теперь поддерживают эту функцию. Microsoft Visual Studio 2015 поддерживает. Clang поддерживает. GCC поддерживает.

Интересно, а как насчет этого:

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

Я использовал похожий код, как этот, чтобы сгенерировать шаблон и задаться вопросом, оптимизирует ли компилятор функцию "обертывания".

Существует расширение gcc, которое позволяет использовать лямбда-шаблоны:

// 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);
                          }
              );

где _widgets - это std::tuple< fusion::pair<Key_T, Widget_T>... >

Посмотрите на Boost.Phoenix полиморфные лямбды: http://www.boost.org/doc/libs/1_44_0/libs/spirit/phoenix/doc/html/index.html Кстати, не требует C ++ 0x :)

Я играл с последней компиляцией clang version 5.0.1 с флагом -std=c++17, и теперь есть хорошая поддержка параметров автоматического типа для лямбда-выражений:

#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;
}

Вот одно из решений, которое включает в себя упаковку ламбы в структуру:

template <typename T>                                                   
struct LamT                                                             
{                                                                       
   static void Go()                                                     
   {                                                                    
      auto lam = []()                                                   
      {                                                                 
         T var;                                                         
         std::cout << "lam, type = " << typeid(var).name() << std::endl;
      };                                                                

      lam();                                                            
   }                                                                    
};   

Для использования do:

LamT<int>::Go();  
LamT<char>::Go(); 
#This prints 
lam, type = i
lam, type = c

Основная проблема с этим (помимо лишнего набора текста): вы не можете встроить это определение структуры в другой метод, иначе вы получите (gcc 4.9)

error: a template declaration cannot appear at block scope

Я тоже пробовал это делать:

template <typename T> using LamdaT = decltype(                          
   [](void)                                                          
   {                                                                 
       std::cout << "LambT type = " << typeid(T).name() << std::endl;  
   });

В надежде, что я смогу использовать это так:

LamdaT<int>();      
LamdaT<char>();

Но я получаю ошибку компилятора:

error: lambda-expression in unevaluated context

Так что это не работает ... но даже если бы он был скомпилирован, он имел бы ограниченное использование, потому что нам все равно пришлось бы помещать «using LamdaT» в область действия файла (потому что это шаблон), что своего рода поражает цель лямбды.

Я не уверен, почему никто другой не предлагал этого, но вы можете написать шаблонную функцию, которая возвращает лямбда-функции. Следующее решило мою проблему, причина, по которой я пришел на эту страницу:

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

Теперь, когда мне нужна функция, которая принимает аргумент заданного типа (например, std::string), я просто говорю

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

и теперь f("any string") возвращает 1.0.

Это пример того, что я имею в виду под «шаблонной лямбда-функцией». (Этот конкретный случай используется для автоматического предоставления инертной функции взвешивания, когда кто-то не хочет взвешивать свои данные, какими бы они ни были.)