有一个允许lambda模板的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);
                          }
              );

where _widgets是一个std::tuple< fusion::pair<Key_T, Widget_T>…>

我不知道为什么没有人建议这样做，但是您可以编写一个返回lambda函数的模板函数。下面解决了我的问题，我来这个页面的原因:

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。

这就是我所说的“模板化函数”的一个例子。(这个特殊的情况是用来自动提供一个惰性加权函数，当有人不想加权他们的数据时，不管他们的数据是什么。)

这里有一个解决方案，涉及到将lamba包裹在一个结构中:

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

所以这行不通……但是即使它编译了，它的作用也是有限的 使用，因为我们仍然必须把“使用LamdaT”在文件范围 (因为它是一个模板)这在某种程度上违背了lambdas的目的。

在c++ 11中，lambda函数不能被模板化，但是在下一个版本的ISO c++标准(通常称为c++ 14)中，将引入这个特性。(来源)

使用的例子:

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

注意，尽管语法使用了关键字auto，但类型推导不会使用auto类型推导的规则，而是使用模板参数推导的规则。另请参阅通用lambda表达式的建议(以及对此的更新)。

我知道这个问题是关于c++ 11的。然而，对于那些在谷歌上搜索并登陆这个页面的人来说，c++ 14现在支持模板化lambdas，并被称为泛型lambdas。

现在大多数流行的编译器都支持这个特性。微软Visual Studio 2015支持。叮当声的支持。GCC支持。

c++ 11 lambda不能像其他答案中所述的那样被模板化，但当在模板化的类或函数中使用lambda时，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

我发现这种技术在处理模板化代码时很有帮助，但意识到它仍然意味着lambdas本身不能被模板化。