虽然模板方法出于各种原因很聪明，但重要的是要记住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应该工作[运行捕获类型的析构函数])。

虽然模板方法出于各种原因很聪明，但重要的是要记住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 with作为C函数指针的快捷方式是:

"auto fun = +[](){}"

以Curl为例(Curl调试信息)

auto callback = +[](CURL* handle, curl_infotype type, char* data, size_t size, void*){ //add code here :-) };
curl_easy_setopt(curlHande, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curlHande,CURLOPT_DEBUGFUNCTION,callback);

这不是一个直接的答案，而是使用“functor”模板模式来隐藏lambda类型的细节，并保持代码的美观和简单。

我不确定你想如何使用决定类，所以我必须用一个使用它的函数扩展类。完整示例请参见:https://godbolt.org/z/jtByqE

类的基本形式可能是这样的:

template <typename Functor>
class Decide
{
public:
    Decide(Functor dec) : _dec{dec} {}
private:
    Functor _dec;
};

将函数类型作为类类型的一部分传入，如下所示:

auto decide_fc = [](int x){ return x > 3; };
Decide<decltype(decide_fc)> greaterThanThree{decide_fc};

再一次，我不确定为什么你要捕捉x它更有意义(对我来说)有一个参数，你传递给lambda)，所以你可以像这样使用:

int result = _dec(5); // or whatever value

有关完整示例，请参见链接

一个类似的答案，但我这样做是为了让你不必指定返回指针的类型(注意，通用版本需要c++ 20):

#include <iostream>


template<typename Function>
struct function_traits;

template <typename Ret, typename... Args>
struct function_traits<Ret(Args...)> {
    typedef Ret(*ptr)(Args...);
};

template <typename Ret, typename... Args>
struct function_traits<Ret(*const)(Args...)> : function_traits<Ret(Args...)> {};

template <typename Cls, typename Ret, typename... Args>
struct function_traits<Ret(Cls::*)(Args...) const> : function_traits<Ret(Args...)> {};

using voidfun = void(*)();

template <typename F>
voidfun lambda_to_void_function(F lambda) {
    static auto lambda_copy = lambda;

    return []() {
        lambda_copy();
    };
}

// requires C++20
template <typename F>
auto lambda_to_pointer(F lambda) -> typename function_traits<decltype(&F::operator())>::ptr {
    static auto lambda_copy = lambda;
    
    return []<typename... Args>(Args... args) {
        return lambda_copy(args...);
    };
}



int main() {
    int num;

    void(*foo)() = lambda_to_void_function([&num]() {
        num = 1234;
    });
    foo();
    std::cout << num << std::endl; // 1234

    int(*bar)(int) = lambda_to_pointer([&](int a) -> int {
        num = a;
        return a;
    });
    std::cout << bar(4321) << std::endl; // 4321
    std::cout << num << std::endl; // 4321
}