blocks|key|23018|text|正如其他人所提到的，你可以用Lambda函数代替函数指针。我在我的C%2B%2B接口中使用这个方法来F77+ODE求解器RKSUITE。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|23019|//C+interface+to+Fortran+subroutine+UT
extern+"C"++void+UT(void(*)(double*,double*,double*),double*,double*,double*,
double*,double*,double*,int*);

//+C%2B%2B+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);|code-block|syntax|javascript|23020|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As it was mentioned by the others you can substitute Lambda function instead of function pointer. I am using this method in my C++ interface to F77 ODE solver RKSUITE.

<pre><code>//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)-&gt;void{YP[0]=Y[1]; YP[1]= -Y[0];}, TWANT,T,Y,YP,YMAX,WORK,UFLAG);
</code></pre>

blocks|key|4530662|text|Lambda表达式，即使是捕获的表达式，也可以作为函数指针(指向成员函数的指针)来处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4530663|这很棘手，因为lambda表达式不是一个简单的函数。它实际上是一个带有运算符()的对象。|4530664|当你有创造力的时候，你可以使用这个！想一想std::function风格的"function“类。如果你保存对象，你也可以使用函数指针。|4530665|要使用函数指针，可以使用以下命令：|4530666|int+first+=+5;
auto+lambda+=+[=](int+x,+int+z)+{
++++return+x+%2B+z+%2B+first;
};
int(decltype(lambda)::*ptr)(int,+int)const+=+&decltype(lambda)::operator();
std::cout+<<+"test+=+"+<<+(lambda.*ptr)(2,+3)+<<+std::endl;|code-block|syntax|javascript|4530667|要构建一个可以像"std::+function“一样工作的类，首先需要一个可以存储对象和函数指针的类/结构。您还需要一个运算符()来执行它：|4530668|//+OT+=>+Object+Type
//+RT+=>+Return+Type
//+A+...+=>+Arguments
template<typename+OT,+typename+RT,+typename+...+A>
struct+lambda_expression+{
++++OT+_object;
++++RT(OT::*_function)(A...)const;

++++lambda_expression(const+OT+&+object)
++++++++:+_object(object),+_function(&decltype(_object)::operator())+{}

++++RT+operator()+(A+...+args)+const+{
++++++++return+(_object.*_function)(args...);
++++}
};|4530669|这样，您现在就可以运行捕获的、非捕获的lambdas，就像使用原始的一样：|4530670|auto+capture_lambda()+{
++++int+first+=+5;
++++auto+lambda+=+[=](int+x,+int+z)+{
++++++++return+x+%2B+z+%2B+first;
++++};
++++return+lambda_expression<decltype(lambda),+int,+int,+int>(lambda);
}

auto+noncapture_lambda()+{
++++auto+lambda+=+[](int+x,+int+z)+{
++++++++return+x+%2B+z;
++++};
++++return+lambda_expression<decltype(lambda),+int,+int,+int>(lambda);
}

void+refcapture_lambda()+{
++++int+test;
++++auto+lambda+=+[&](int+x,+int+z)+{
++++++++test+=+x+%2B+z;
++++};
++++lambda_expression<decltype(lambda),+void,+int,+int>f(lambda);
++++f(2,+3);

++++std::cout+<<+"test+value+=+"+<<+test+<<+std::endl;
}

int+main(int+argc,+char+**argv)+{
++++auto+f_capture+=+capture_lambda();
++++auto+f_noncapture+=+noncapture_lambda();

++++std::cout+<<+"main+test+=+"+<<+f_capture(2,+3)+<<+std::endl;
++++std::cout+<<+"main+test+=+"+<<+f_noncapture(2,+3)+<<+std::endl;

++++refcapture_lambda();

++++system("PAUSE");
++++return+0;
}|4530671|此代码适用于VS2015|4530672|更新04.07.17：|4530673|template+<typename+CT,+typename+...+A>+struct+function
:+public+function<decltype(&CT::operator())(A...)>+{};

template+<typename+C>+struct+function<C>+{
private:
++++C+mObject;

public:
++++function(const+C+&+obj)
++++++++:+mObject(obj)+{}

++++template<typename...+Args>+typename+
++++std::result_of<C(Args...)>::type+operator()(Args...+a)+{
++++++++return+this->mObject.operator()(a...);
++++}

++++template<typename...+Args>+typename+
++++std::result_of<const+C(Args...)>::type+operator()(Args...+a)+const+{
++++++++return+this->mObject.operator()(a...);
++++}
};

namespace+make+{
++++template<typename+C>+auto+function(const+C+&+obj)+{
++++++++return+::function<C>(obj);
++++}
}

int+main(int+argc,+char+**+argv)+{
+++auto+func+=+make::function([](int+y,+int+x)+{+return+x*y;+});
+++std::cout+<<+func(2,+4)+<<+std::endl;
+++system("PAUSE");
+++return+0;
}|4530674|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|J|7|1D|8|@]|9|@]|A|$K|L]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Lambda expressions, even captured ones, can be handled as a function pointer (pointer to member function).

It is tricky because an lambda expression is not a simple function. It is actually an object with an operator().

When you are creative, you can use this! 
Think of an "function" class in style of std::function. 
If you save the object you also can use the function pointer.

To use the function pointer, you can use the following:

<pre><code>int first = 5;
auto lambda = [=](int x, int z) {
 return x + z + first;
};
int(decltype(lambda)::*ptr)(int, int)const = &amp;decltype(lambda)::operator();
std::cout &lt;&lt; "test = " &lt;&lt; (lambda.*ptr)(2, 3) &lt;&lt; std::endl;
</code></pre>

To build a class that can start working like a "std::function", first you need a class/struct than can store object and function pointer. Also you need an operator() to execute it:

<pre><code>// OT =&gt; Object Type
// RT =&gt; Return Type
// A ... =&gt; Arguments
template&lt;typename OT, typename RT, typename ... A&gt;
struct lambda_expression {
 OT _object;
 RT(OT::*_function)(A...)const;

 lambda_expression(const OT &amp; object)
 : _object(object), _function(&amp;decltype(_object)::operator()) {}

 RT operator() (A ... args) const {
 return (_object.*_function)(args...);
 }
};
</code></pre>

With this you can now run captured, non-captured lambdas, just like you are using the original:

<pre><code>auto capture_lambda() {
 int first = 5;
 auto lambda = [=](int x, int z) {
 return x + z + first;
 };
 return lambda_expression&lt;decltype(lambda), int, int, int&gt;(lambda);
}

auto noncapture_lambda() {
 auto lambda = [](int x, int z) {
 return x + z;
 };
 return lambda_expression&lt;decltype(lambda), int, int, int&gt;(lambda);
}

void refcapture_lambda() {
 int test;
 auto lambda = [&amp;](int x, int z) {
 test = x + z;
 };
 lambda_expression&lt;decltype(lambda), void, int, int&gt;f(lambda);
 f(2, 3);

 std::cout &lt;&lt; "test value = " &lt;&lt; test &lt;&lt; std::endl;
}

int main(int argc, char **argv) {
 auto f_capture = capture_lambda();
 auto f_noncapture = noncapture_lambda();

 std::cout &lt;&lt; "main test = " &lt;&lt; f_capture(2, 3) &lt;&lt; std::endl;
 std::cout &lt;&lt; "main test = " &lt;&lt; f_noncapture(2, 3) &lt;&lt; std::endl;

 refcapture_lambda();

 system("PAUSE");
 return 0;
}
</code></pre>

This code works with VS2015

Update 04.07.17:

<pre><code>template &lt;typename CT, typename ... A&gt; struct function
: public function&lt;decltype(&amp;CT::operator())(A...)&gt; {};

template &lt;typename C&gt; struct function&lt;C&gt; {
private:
 C mObject;

public:
 function(const C &amp; obj)
 : mObject(obj) {}

 template&lt;typename... Args&gt; typename 
 std::result_of&lt;C(Args...)&gt;::type operator()(Args... a) {
 return this-&gt;mObject.operator()(a...);
 }

 template&lt;typename... Args&gt; typename 
 std::result_of&lt;const C(Args...)&gt;::type operator()(Args... a) const {
 return this-&gt;mObject.operator()(a...);
 }
};

namespace make {
 template&lt;typename C&gt; auto function(const C &amp; obj) {
 return ::function&lt;C&gt;(obj);
 }
}

int main(int argc, char ** argv) {
 auto func = make::function([](int y, int x) { return x*y; });
 std::cout &lt;&lt; func(2, 4) &lt;&lt; std::endl;
 system("PAUSE");
 return 0;
}
</code></pre>

blocks|key|23175|text|正如this+answer指出的那样，捕获lambda不能转换为函数指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|23176|然而，向只接受一个函数指针的API提供一个函数指针通常是一件相当痛苦的事情。最常被引用的方法是提供一个函数并用它调用一个静态对象。|23177|static+Callable+callable;
static+bool+wrapper()
{
++++return+callable();
}|code-block|syntax|javascript|23178|这太乏味了。我们进一步发展了这个想法，并自动化了创建wrapper的过程，使生活变得更加容易。|style|CODE|23179|#include<type_traits>
#include<utility>

template<typename+Callable>
union+storage
{
++++storage()+{}
++++std::decay_t<Callable>+callable;
};

template<int,+typename+Callable,+typename+Ret,+typename...+Args>
auto+fnptr_(Callable&&+c,+Ret+(*)(Args...))
{
++++static+bool+used+=+false;
++++static+storage<Callable>+s;
++++using+type+=+decltype(s.callable);

++++if(used)
++++++++s.callable.~type();
++++new+(&s.callable)+type(std::forward<Callable>(c));
++++used+=+true;

++++return+[](Args...+args)+->+Ret+{
++++++++return+Ret(s.callable(std::forward<Args>(args)...));
++++};
}

template<typename+Fn,+int+N+=+0,+typename+Callable>
Fn*+fnptr(Callable&&+c)
{
++++return+fnptr_<N>(std::forward<Callable>(c),+(Fn*)nullptr);
}|23180|并将其用作|23181|void+foo(void+(*fn)())
{
++++fn();+++
}

int+main()
{
++++int+i+=+42;
++++auto+fn+=+fnptr<void()>([i]{std::cout+<<+i;});
++++foo(fn);++//+compiles!
}|23182|Live|23183|这实际上是在每次出现fnptr时声明一个匿名函数。|23184|请注意，在给定相同类型的可调用函数的情况下，对fnptr的调用会覆盖先前编写的callable。我们使用int参数N在一定程度上解决了这个问题。|23185|std::function<void()>+func1,+func2;
auto+fn1+=+fnptr<void(),+1>(func1);
auto+fn2+=+fnptr<void(),+2>(func2);++//+different+function|23186|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/28746827/4832499|1|http://coliru.stacked-crooked.com/a/95fa363082823d82^0|2|B|0|0|0|0|Q|7|0|0|0|0|0|4|1|0|A|5|0|N|5|13|8|1G|3|1L|1|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]]|C|$]]|$1|D|3|E|5|6|7|1G|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1H|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1I|8|@$A|1J|B|1K|M|N]]|9|@]|C|$]]|$1|O|3|P|5|H|7|1L|8|@]|9|@]|C|$I|J]]|$1|Q|3|R|5|6|7|1M|8|@]|9|@]|C|$]]|$1|S|3|T|5|H|7|1N|8|@]|9|@]|C|$I|J]]|$1|U|3|V|5|6|7|1O|8|@]|9|@$A|1P|B|1Q|1|1R]]|C|$]]|$1|W|3|X|5|6|7|1S|8|@$A|1T|B|1U|M|N]]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|1V|8|@$A|1W|B|1X|M|N]|$A|1Y|B|1Z|M|N]|$A|20|B|21|M|N]|$A|22|B|23|M|N]]|9|@]|C|$]]|$1|10|3|11|5|H|7|24|8|@]|9|@]|C|$I|J]]|$1|12|3|-4|5|6|7|25|8|@]|9|@]|C|$]]]|13|$14|$5|15|16|17|C|$18|19]]|1A|$5|15|16|17|C|$18|1B]]]]

Capturing lambdas cannot be converted to function pointers, as <a href="https://stackoverflow.com/a/28746827/4832499">this answer</a> pointed out.

However, it is often quite a pain to supply a function pointer to an API that only accepts one. The most often cited method to do so is to provide a function and call a static object with it.

<pre><code>static Callable callable;
static bool wrapper()
{
 return callable();
}
</code></pre>

This is tedious. We take this idea further and automate the process of creating <code>wrapper</code> and make life much easier.

<pre><code>#include&lt;type_traits&gt;
#include&lt;utility&gt;

template&lt;typename Callable&gt;
union storage
{
 storage() {}
 std::decay_t&lt;Callable&gt; callable;
};

template&lt;int, typename Callable, typename Ret, typename... Args&gt;
auto fnptr_(Callable&amp;&amp; c, Ret (*)(Args...))
{
 static bool used = false;
 static storage&lt;Callable&gt; s;
 using type = decltype(s.callable);

 if(used)
 s.callable.~type();
 new (&amp;s.callable) type(std::forward&lt;Callable&gt;(c));
 used = true;

 return [](Args... args) -&gt; Ret {
 return Ret(s.callable(std::forward&lt;Args&gt;(args)...));
 };
}

template&lt;typename Fn, int N = 0, typename Callable&gt;
Fn* fnptr(Callable&amp;&amp; c)
{
 return fnptr_&lt;N&gt;(std::forward&lt;Callable&gt;(c), (Fn*)nullptr);
}
</code></pre>

And use it as

<pre><code>void foo(void (*fn)())
{
 fn(); 
}

int main()
{
 int i = 42;
 auto fn = fnptr&lt;void()&gt;([i]{std::cout &lt;&lt; i;});
 foo(fn); // compiles!
}
</code></pre>

<a href="http://coliru.stacked-crooked.com/a/95fa363082823d82" rel="noreferrer">Live</a>

This is essentially declaring an anonymous function at each occurrence of <code>fnptr</code>.

Note that invocations of <code>fnptr</code> overwrite the previously written <code>callable</code> given callables of the same type. We remedy this, to a certain degree, with the <code>int</code> parameter <code>N</code>.

<pre><code>std::function&lt;void()&gt; func1, func2;
auto fn1 = fnptr&lt;void(), 1&gt;(func1);
auto fn2 = fnptr&lt;void(), 2&gt;(func2); // different function
</code></pre>

blocks|key|23263|text|尽管由于各种原因，模板方法很聪明，但记住lambda和捕获的变量的生命周期是很重要的。如果要使用任何形式的lambda指针，并且lambda不是向下延续，则只应使用copying+=+lambda。也就是说，即使这样，如果捕获的指针的生命周期(堆栈展开)比lambda的生命周期短，那么捕获指向堆栈上的变量的指针是不安全的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|23264|将lambda捕获为指针的一种更简单的解决方案是：|23265|auto+pLamdba+=+new+std::function<...fn-sig...>([=](...fn-sig...){...});|code-block|syntax|javascript|23266|例如，new+std::function<void()>([=]()+->+void+{...}|offset|length|style|CODE|23267|只需记住稍后的delete+pLamdba，以确保您不会泄漏lambda内存。这里要认识到的秘密是，lambda可以捕获lambda+(问问自己是如何工作的)，而且为了让std::function正常工作，lambda实现需要包含足够的内部信息来提供对lambda(和捕获的)数据大小的访问(这就是为什么delete应该运行捕获类型的析构函数)。|23268|entityMap^0|0|0|0|3|19|0|7|E|2D|D|48|6|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@$K|Z|L|10|M|N]|$K|11|L|12|M|N]|$K|13|L|14|M|N]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

While the template approach is clever for various reasons, it is important to remember the lifecycle of the lambda and the captured variables. If any form of a lambda pointer is is going to be used and the lambda is not a downward continuation, then only a copying [=] lambda should used. I.e., even then, capturing a pointer to a variable on the stack is UNSAFE if the lifetime of those captured pointers (stack unwind) is shorter than the lifetime of the lambda.

A simpler solution for capturing a lambda as a pointer is:

<pre><code>auto pLamdba = new std::function&lt;...fn-sig...&gt;([=](...fn-sig...){...});
</code></pre>

e.g., <code>new std::function&lt;void()&gt;([=]() -&gt; void {...}</code>

Just remember to later <code>delete pLamdba</code> so ensure that you don't leak the lambda memory.
Secret to realize here is that lambdas can capture lambdas (ask yourself how that works) and also that in order for <code>std::function</code> to work generically the lambda implementation needs to contain sufficient internal information to provide access to the size of the lambda (and captured) data (which is why the <code>delete</code> should work [running destructors of captured types]).

blocks|key|4530858|text|将lambda用作C函数指针的快捷方式如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4530859|"auto+fun+=+%2B[](){}"|code-block|syntax|javascript|4530860|使用Curl作为示例(curl+debug+info)|offset|length|4530861|auto+callback+=+%2B[](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);|4530862|entityMap|0|LINK|mutability|MUTABLE|url|https://curl.haxx.se/libcurl/c/CURLOPT_DEBUGFUNCTION.html^0|0|0|B|F|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

A shortcut for using a lambda with as a C function pointer is this:

<pre><code>"auto fun = +[](){}"
</code></pre>

Using Curl as exmample (<a href="https://curl.haxx.se/libcurl/c/CURLOPT_DEBUGFUNCTION.html" rel="nofollow noreferrer">curl debug info</a>) 

<pre><code>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);
</code></pre>

blocks|key|23344|text|这不是一个直接的答案，而是使用"functor“模板模式来隐藏lambda类型的细节并保持代码的简洁性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|23345|我不确定您希望如何使用decide类，因此我必须使用一个使用它的函数来扩展该类。在这里查看完整的示例：https://godbolt.org/z/jtByqE|offset|length|23346|类的基本形式可能如下所示：|23347|template+<typename+Functor>
class+Decide
{
public:
++++Decide(Functor+dec)+:+_dec{dec}+{}
private:
++++Functor+_dec;
};|code-block|syntax|javascript|23348|其中，将函数的类型作为使用的类类型的一部分进行传递，如下所示：|23349|auto+decide_fc+=+[](int+x){+return+x+>+3;+};
Decide<decltype(decide_fc)>+greaterThanThree{decide_fc};|23350|同样，我不确定你为什么要捕获x+(对我来说)更有意义的是有一个参数传递给lambda)，这样你就可以像这样使用：|style|CODE|23351|int+result+=+_dec(5);+//+or+whatever+value|23352|有关完整的示例，请参阅链接|23353|entityMap|0|LINK|mutability|MUTABLE|url|https://godbolt.org/z/jtByqE^0|0|1F|S|0|0|0|0|0|0|E|1|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1E|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@$D|1G|E|1H|S|T]]|9|@]|A|$]]|$1|U|3|V|5|J|7|1I|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

Not a direct answer, but a slight variation to use the "functor" template pattern to hide away the specifics of the lambda type and keeps the code nice and simple.

I was not sure how you wanted to use the decide class so I had to extend the class with a function that uses it. See full example here: <a href="https://godbolt.org/z/jtByqE" rel="nofollow noreferrer">https://godbolt.org/z/jtByqE</a>

The basic form of your class might look like this:

<pre><code>template &lt;typename Functor&gt;
class Decide
{
public:
 Decide(Functor dec) : _dec{dec} {}
private:
 Functor _dec;
};
</code></pre>

Where you pass the type of the function in as part of the class type used like:

<pre><code>auto decide_fc = [](int x){ return x &gt; 3; };
Decide&lt;decltype(decide_fc)&gt; greaterThanThree{decide_fc};
</code></pre>

Again, I was not sure why you are capturing <code>x</code> it made more sense (to me) to have a parameter that you pass in to the lambda) so you can use like:

<pre><code>int result = _dec(5); // or whatever value
</code></pre>

See the link for a complete example

blocks|key|23387|text|一个类似的答案，但我这样做了，这样你就不必指定返回指针的类型(请注意，通用版本需要C%2B%2B20)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|23388|#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%2B%2B20
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
}|code-block|syntax|javascript|23389|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A simular answer but i made it so you don't have to specify the type of returned pointer (note that the generic version requires C++20):
<pre><code>#include &lt;iostream&gt;


template&lt;typename Function&gt;
struct function_traits;

template &lt;typename Ret, typename... Args&gt;
struct function_traits&lt;Ret(Args...)&gt; {
 typedef Ret(*ptr)(Args...);
};

template &lt;typename Ret, typename... Args&gt;
struct function_traits&lt;Ret(*const)(Args...)&gt; : function_traits&lt;Ret(Args...)&gt; {};

template &lt;typename Cls, typename Ret, typename... Args&gt;
struct function_traits&lt;Ret(Cls::*)(Args...) const&gt; : function_traits&lt;Ret(Args...)&gt; {};

using voidfun = void(*)();

template &lt;typename F&gt;
voidfun lambda_to_void_function(F lambda) {
 static auto lambda_copy = lambda;

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

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



int main() {
 int num;

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

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

Is it possible to pass a lambda function as a function pointer? If so, I must be doing something incorrectly because I am getting a compile error.

Consider the following example

<pre><code>using DecisionFn = bool(*)();

class Decide
{
public:
 Decide(DecisionFn dec) : _dec{dec} {}
private:
 DecisionFn _dec;
};

int main()
{
 int x = 5;
 Decide greaterThanThree{ [x](){ return x &gt; 3; } };
 return 0;
}
</code></pre>

When I <a href="http://cpp.sh/5x5r">try to compile this</a>, I get the following compilation error:

<pre class="lang-none prettyprint-override"><code>In function 'int main()':
17:31: error: the value of 'x' is not usable in a constant expression
16:9: note: 'int x' is not const
17:53: error: no matching function for call to 'Decide::Decide(&lt;brace-enclosed initializer list&gt;)'
17:53: note: candidates are:
9:5: note: Decide::Decide(DecisionFn)
9:5: note: no known conversion for argument 1 from 'main()::&lt;lambda()&gt;' to 'DecisionFn {aka bool (*)()}'
6:7: note: constexpr Decide::Decide(const Decide&amp;)
6:7: note: no known conversion for argument 1 from 'main()::&lt;lambda()&gt;' to 'const Decide&amp;'
6:7: note: constexpr Decide::Decide(Decide&amp;&amp;)
6:7: note: no known conversion for argument 1 from 'main()::&lt;lambda()&gt;' to 'Decide&amp;&amp;'
</code></pre>

That's one heck of an error message to digest, but I think what I'm getting out of it is that the lambda cannot be treated as a <code>constexpr</code> so therefore I cannot pass it as a function pointer? I've tried making <code>x</code> const as well, but that doesn't seem to help.

Passing capturing lambda as function pointer

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

可以将lambda函数作为函数指针传递吗？如果是这样，我一定是做错了什么，因为我得到了一个编译错误。考虑下面的例子using DecisionFn = bool(*)();class Decide{public:    Decide(DecisionFn dec) : _dec{dec} {}private:    D...

问将捕获lambda作为函数指针传递
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将捕获lambda作为函数指针传递EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将捕获lambda作为函数指针传递
EN