如果lambda没有捕获，则只能将其转换为函数指针，摘自c++ 11标准草案5.1.2节[expr.prim. xml]。Lambda]表示(强调我的):

没有lambda捕获的lambda表达式的闭包类型具有 到指针的公共非虚拟非显式const转换函数 函数具有与闭包相同的参数和返回类型 类型的函数调用操作符。此转换返回的值 Function应是函数的地址，该函数在调用时具有 与调用闭包类型的函数调用操作符的效果相同。

注意，cppreference在Lambda函数一节中也介绍了这一点。

因此，以下选择是可行的:

typedef bool(*DecisionFn)(int);

Decide greaterThanThree{ []( int x ){ return x > 3; } };

这个也一样:

typedef bool(*DecisionFn)();

Decide greaterThanThree{ [](){ return true ; } };

正如5gon12eder所指出的，您也可以使用std::function，但请注意std::function是很重要的，所以它不是一个无成本的权衡。

如果lambda没有捕获，则只能将其转换为函数指针，摘自c++ 11标准草案5.1.2节[expr.prim. xml]。Lambda]表示(强调我的):

没有lambda捕获的lambda表达式的闭包类型具有 到指针的公共非虚拟非显式const转换函数 函数具有与闭包相同的参数和返回类型 类型的函数调用操作符。此转换返回的值 Function应是函数的地址，该函数在调用时具有 与调用闭包类型的函数调用操作符的效果相同。

注意，cppreference在Lambda函数一节中也介绍了这一点。

因此，以下选择是可行的:

typedef bool(*DecisionFn)(int);

Decide greaterThanThree{ []( int x ){ return x > 3; } };

这个也一样:

typedef bool(*DecisionFn)();

Decide greaterThanThree{ [](){ return true ; } };

正如5gon12eder所指出的，您也可以使用std::function，但请注意std::function是很重要的，所以它不是一个无成本的权衡。

Shafik Yaghmour的答案正确地解释了为什么lambda不能作为函数指针传递，如果它有一个捕获。我想介绍两个简单的解决方法。

Use std::function instead of raw function pointers. This is a very clean solution. Note however that it includes some additional overhead for the type erasure (probably a virtual function call). #include <functional> #include <utility> struct Decide { using DecisionFn = std::function<bool()>; Decide(DecisionFn dec) : dec_ {std::move(dec)} {} DecisionFn dec_; }; int main() { int x = 5; Decide greaterThanThree { [x](){ return x > 3; } }; } Use a lambda expression that doesn't capture anything. Since your predicate is really just a boolean constant, the following would quickly work around the current issue. See this answer for a good explanation why and how this is working. // Your 'Decide' class as in your post. int main() { int x = 5; Decide greaterThanThree { (x > 3) ? [](){ return true; } : [](){ return false; } }; }

虽然模板方法出于各种原因很聪明，但重要的是要记住lambda和捕获的变量的生命周期。如果要使用任何形式的lambda指针is，并且lambda不是向下延续，那么只应该使用复制[=]lambda。也就是说，即使这样，如果捕获的指针的生命周期(堆栈unwind)比lambda的生命周期短，那么在堆栈上捕获一个指向变量的指针也是不安全的。

捕获lambda作为指针的一个更简单的解决方案是:

auto pLamdba = new std::function<...fn-sig...>([=](...fn-sig...){...});

例如,新std::函数<空白 ()>([=]() -> 空白{…}

只需要记住稍后删除pLamdba，以确保不会泄漏lambda内存。 这里要意识到的秘密是lambdas可以捕获lambdas(问问自己这是如何工作的)，而且为了让std::function正常工作，lambda实现需要包含足够的内部信息来提供对lambda(和捕获的)数据大小的访问(这就是为什么delete应该工作[运行捕获类型的析构函数])。

这是另一种解决方案。c++ 14(可以转换为c++ 11)支持返回值、不可复制和可变lambda。如果不需要可变的lambdas，可以通过删除匹配非const版本的专门化并嵌入impl_impl来更短。

对于那些想知道的人来说，它是有效的，因为每个lambda都是唯一的(是不同的类)，因此调用to_f会为这个lambda静态和相应的c风格函数生成唯一的，可以访问它。

template <class L, class R, class... Args> static auto impl_impl(L l) {
  static_assert(!std::is_same<L, std::function<R(Args...)>>::value,
                "Only lambdas are supported, it is unsafe to use "
                "std::function or other non-lambda callables");

    static L lambda_s = std::move(l);
    return +[](Args... args) -> R { return lambda_s(args...); };
}

template <class L>
struct to_f_impl : public to_f_impl<decltype(&L::operator())> {};
template <class ClassType, class R, class... Args>
struct to_f_impl<R (ClassType::*)(Args...) const> {
  template <class L> static auto impl(L l) {
    return impl_impl<L, R, Args...>(std::move(l));
  }
};
template <class ClassType, class R, class... Args>
struct to_f_impl<R (ClassType::*)(Args...)> {
  template <class L> static auto impl(L l) {
    return impl_impl<L, R, Args...>(std::move(l));
  }
};

template <class L> auto to_f(L l) { return to_f_impl<L>::impl(std::move(l)); }

注意，这也适用于其他可调用的对象，如std::function，但如果它不起作用会更好，因为与lambdas不同，std::function这样的对象不会生成唯一类型，因此内部模板和它的内部静态将被所有具有相同签名的函数重用/共享，这很可能不是我们想从它那里得到的。我已经明确禁止std::函数，但还有更多我不知道如何以通用的方式禁止。

正如其他人提到的，你可以用Lambda函数代替函数指针。我使用这个方法在我的c++接口到F77 ODE求解器RKSUITE。

//C interface to Fortran subroutine UT
extern "C"  void UT(void(*)(double*,double*,double*),double*,double*,double*,
double*,double*,double*,int*);

// C++ wrapper which calls extern "C" void UT routine
static  void   rk_ut(void(*)(double*,double*,double*),double*,double*,double*,
double*,double*,double*,int*);

//  Call of rk_ut with lambda passed instead of function pointer to derivative
//  routine
mathlib::RungeKuttaSolver::rk_ut([](double* T,double* Y,double* YP)->void{YP[0]=Y[1]; YP[1]= -Y[0];}, TWANT,T,Y,YP,YMAX,WORK,UFLAG);