blocks|key|1358580|text|您正在尝试捕获一个正在定义的变量(sum)。这可不是什么好事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1358581|我不认为真正的自递归C%2B%2B0x+lambda是可能的。不过，您应该能够捕获其他lambda。|1358582|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You're trying to capture a variable (sum) you're in the middle of defining. That can't be good.

I don't think truely self-recursive C++0x lambdas are possible. You should be able to capture other lambdas, though.

blocks|key|1143453|text|你需要一个定点组合器。参见this。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1143454|或者查看以下代码：|1143455|//As+decltype(variable)::member_name+is+invalid+currently,+
//the+following+template+is+a+workaround.
//Usage:+t2t<decltype(variable)>::t::member_name
template<typename+T>
struct+t2t
{
++++typedef+T+t;
};

template<typename+R,+typename+V>
struct+fixpoint
{
++++typedef+std::function<R+(V)>+func_t;
++++typedef+std::function<func_t+(func_t)>+tfunc_t;
++++typedef+std::function<func_t+(tfunc_t)>+yfunc_t;

++++class+loopfunc_t+{
++++public:
++++++++func_t+operator()(loopfunc_t+v)const+{
++++++++++++return+func(v);
++++++++}
++++++++template<typename+L>
++++++++loopfunc_t(const+L+&l):func(l){}
++++++++typedef+V+Parameter_t;
++++private:
++++++++std::function<func_t+(loopfunc_t)>+func;
++++};
++++static+yfunc_t+fix;
};
template<typename+R,+typename+V>
typename+fixpoint<R,+V>::yfunc_t+fixpoint<R,+V>::fix+=+
[](fixpoint<R,+V>::tfunc_t+f)+->+fixpoint<R,+V>::func_t+{
++++fixpoint<R,+V>::loopfunc_t+l+=+[f](fixpoint<R,+V>::loopfunc_t+x)+->
++++++++fixpoint<R,+V>::func_t{
++++++++++++//f+cannot+be+captured+since+it+is+not+a+local+variable
++++++++++++//of+this+scope.+We+need+a+new+reference+to+it.
++++++++++++auto+&ff+=+f;
++++++++++++//We+need+struct+t2t+because+template+parameter
++++++++++++//V+is+not+accessable+in+this+level.
++++++++++++return+[ff,+x](t2t<decltype(x)>::t::Parameter_t+v){
++++++++++++++++return+ff(x(x))(v);+
++++++++++++};
++++++++};+
++++++++return+l(l);
++++};

int+_tmain(int+argc,+_TCHAR*+argv[])
{
++++int+v+=+0;
++++std::function<int+(int)>+fac+=+
++++fixpoint<int,+int>::fix([](std::function<int+(int)>+f)
++++++++->+std::function<int+(int)>{
++++++++return+[f](int+i)+->+int{
++++++++++++if(i==0)+return+1;
++++++++++++else+return+i+*+f(i-1);
++++++++};
++++});

++++int+i+=+fac(10);
++++std::cout+<<+i;+//3628800
++++return+0;
}|code-block|syntax|javascript|1143456|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/6453011/my-implementation-of-fixed-point-combinator-in-c0x-compiled-under-vistual-stud^0|D|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You need a fixed point combinator. See <a href="https://stackoverflow.com/questions/6453011/my-implementation-of-fixed-point-combinator-in-c0x-compiled-under-vistual-stud">this</a>.

or look at the following code:

<pre><code>//As decltype(variable)::member_name is invalid currently, 
//the following template is a workaround.
//Usage: t2t&lt;decltype(variable)&gt;::t::member_name
template&lt;typename T&gt;
struct t2t
{
 typedef T t;
};

template&lt;typename R, typename V&gt;
struct fixpoint
{
 typedef std::function&lt;R (V)&gt; func_t;
 typedef std::function&lt;func_t (func_t)&gt; tfunc_t;
 typedef std::function&lt;func_t (tfunc_t)&gt; yfunc_t;

 class loopfunc_t {
 public:
 func_t operator()(loopfunc_t v)const {
 return func(v);
 }
 template&lt;typename L&gt;
 loopfunc_t(const L &amp;l):func(l){}
 typedef V Parameter_t;
 private:
 std::function&lt;func_t (loopfunc_t)&gt; func;
 };
 static yfunc_t fix;
};
template&lt;typename R, typename V&gt;
typename fixpoint&lt;R, V&gt;::yfunc_t fixpoint&lt;R, V&gt;::fix = 
[](fixpoint&lt;R, V&gt;::tfunc_t f) -&gt; fixpoint&lt;R, V&gt;::func_t {
 fixpoint&lt;R, V&gt;::loopfunc_t l = [f](fixpoint&lt;R, V&gt;::loopfunc_t x) -&gt;
 fixpoint&lt;R, V&gt;::func_t{
 //f cannot be captured since it is not a local variable
 //of this scope. We need a new reference to it.
 auto &amp;ff = f;
 //We need struct t2t because template parameter
 //V is not accessable in this level.
 return [ff, x](t2t&lt;decltype(x)&gt;::t::Parameter_t v){
 return ff(x(x))(v); 
 };
 }; 
 return l(l);
 };

int _tmain(int argc, _TCHAR* argv[])
{
 int v = 0;
 std::function&lt;int (int)&gt; fac = 
 fixpoint&lt;int, int&gt;::fix([](std::function&lt;int (int)&gt; f)
 -&gt; std::function&lt;int (int)&gt;{
 return [f](int i) -&gt; int{
 if(i==0) return 1;
 else return i * f(i-1);
 };
 });

 int i = fac(10);
 std::cout &lt;&lt; i; //3628800
 return 0;
}
</code></pre>

blocks|key|1143495|text|以下是该操作的最终答案。无论如何，Visual+Studio2010不支持捕获全局变量。而且您不需要捕获它们，因为全局变量可以通过定义全局访问。下面的答案改用局部变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1143496|#include+<functional>
#include+<iostream>

template<typename+T>
struct+t2t
{
++++typedef+T+t;
};

template<typename+R,+typename+V1,+typename+V2>
struct+fixpoint
{
++++typedef+std::function<R+(V1,+V2)>+func_t;
++++typedef+std::function<func_t+(func_t)>+tfunc_t;
++++typedef+std::function<func_t+(tfunc_t)>+yfunc_t;

++++class+loopfunc_t+{
++++public:
++++++++func_t+operator()(loopfunc_t+v)const+{
++++++++++++return+func(v);
++++++++}
++++++++template<typename+L>
++++++++loopfunc_t(const+L+&l):func(l){}
++++++++typedef+V1+Parameter1_t;
++++++++typedef+V2+Parameter2_t;
++++private:
++++++++std::function<func_t+(loopfunc_t)>+func;
++++};
++++static+yfunc_t+fix;
};
template<typename+R,+typename+V1,+typename+V2>
typename+fixpoint<R,+V1,+V2>::yfunc_t+fixpoint<R,+V1,+V2>::fix+=+[](tfunc_t+f)+->+func_t+{
++++return+[f](fixpoint<R,+V1,+V2>::loopfunc_t+x){++return+f(x(x));+}
++++([f](fixpoint<R,+V1,+V2>::loopfunc_t+x)+->+fixpoint<R,+V1,+V2>::func_t{
++++++++auto+&ff+=+f;
++++++++return+[ff,+x](t2t<decltype(x)>::t::Parameter1_t+v1,+
++++++++++++t2t<decltype(x)>::t::Parameter1_t+v2){
++++++++++++return+ff(x(x))(v1,+v2);
++++++++};+
++++});
};

int+_tmain(int+argc,+_TCHAR*+argv[])
{
++++auto+term+=+[](int+a)->int+{
++++++return+a*a;
++++};

++++auto+next+=+[](int+a)->int+{
++++++return+%2B%2Ba;
++++};

++++auto+sum+=+fixpoint<int,+int,+int>::fix(
++++[term,next](std::function<int+(int,+int)>+sum1)+->+std::function<int+(int,+int)>{
++++++++auto+&term1+=+term;
++++++++auto+&next1+=+next;
++++++++return+[term1,+next1,+sum1](int+a,+int+b)mutable+->int+{
++++++++++++if(a>b)
++++++++++++++++return+0;
++++++++else
++++++++++++return+term1(a)+%2B+sum1(next1(a),b);
++++++++};
++++});

++++std::cout<<sum(1,10)<<std::endl;+//385

++++return+0;
}|code-block|syntax|javascript|1143497|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|$]]

Here is the final answer for the OP. Anyway, Visual Studio 2010 does not support capturing global variables. And you do not need to capture them because global variable is accessable globally by define. The following answer uses local variable instead.

<pre><code>#include &lt;functional&gt;
#include &lt;iostream&gt;

template&lt;typename T&gt;
struct t2t
{
 typedef T t;
};

template&lt;typename R, typename V1, typename V2&gt;
struct fixpoint
{
 typedef std::function&lt;R (V1, V2)&gt; func_t;
 typedef std::function&lt;func_t (func_t)&gt; tfunc_t;
 typedef std::function&lt;func_t (tfunc_t)&gt; yfunc_t;

 class loopfunc_t {
 public:
 func_t operator()(loopfunc_t v)const {
 return func(v);
 }
 template&lt;typename L&gt;
 loopfunc_t(const L &amp;l):func(l){}
 typedef V1 Parameter1_t;
 typedef V2 Parameter2_t;
 private:
 std::function&lt;func_t (loopfunc_t)&gt; func;
 };
 static yfunc_t fix;
};
template&lt;typename R, typename V1, typename V2&gt;
typename fixpoint&lt;R, V1, V2&gt;::yfunc_t fixpoint&lt;R, V1, V2&gt;::fix = [](tfunc_t f) -&gt; func_t {
 return [f](fixpoint&lt;R, V1, V2&gt;::loopfunc_t x){ return f(x(x)); }
 ([f](fixpoint&lt;R, V1, V2&gt;::loopfunc_t x) -&gt; fixpoint&lt;R, V1, V2&gt;::func_t{
 auto &amp;ff = f;
 return [ff, x](t2t&lt;decltype(x)&gt;::t::Parameter1_t v1, 
 t2t&lt;decltype(x)&gt;::t::Parameter1_t v2){
 return ff(x(x))(v1, v2);
 }; 
 });
};

int _tmain(int argc, _TCHAR* argv[])
{
 auto term = [](int a)-&gt;int {
 return a*a;
 };

 auto next = [](int a)-&gt;int {
 return ++a;
 };

 auto sum = fixpoint&lt;int, int, int&gt;::fix(
 [term,next](std::function&lt;int (int, int)&gt; sum1) -&gt; std::function&lt;int (int, int)&gt;{
 auto &amp;term1 = term;
 auto &amp;next1 = next;
 return [term1, next1, sum1](int a, int b)mutable -&gt;int {
 if(a&gt;b)
 return 0;
 else
 return term1(a) + sum1(next1(a),b);
 };
 });

 std::cout&lt;&lt;sum(1,10)&lt;&lt;std::endl; //385

 return 0;
}
</code></pre>

blocks|key|1143556|text|我有另一个解决方案，但只能使用无状态lambda：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1143557|void+f()
{
++++static+int+(*self)(int)+=+[](int+i)->int+{+return+i>0+?+self(i-1)*i+:+1;+};
++++std::cout<<self(10);
}|code-block|syntax|javascript|1143558|这里的诀窍是lambdas可以访问静态变量，您可以将无状态变量转换为函数指针。|1143559|您可以将其与标准lambdas一起使用：|1143560|void+g()
{
++++int+sum;
++++auto+rec+=+[&sum](int+i)+->+int
++++{
++++++++static+int+(*inner)(int&,+int)+=+[](int&+_sum,+int+i)->int+
++++++++{
++++++++++++_sum+%2B=+i;
++++++++++++return+i>0+?+inner(_sum,+i-1)*i+:+1;+
++++++++};
++++++++return+inner(sum,+i);
++++};
}|1143561|它在GCC+4.7中的工作|1143562|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I have another solution, but work only with stateless lambdas:

<pre><code>void f()
{
 static int (*self)(int) = [](int i)-&gt;int { return i&gt;0 ? self(i-1)*i : 1; };
 std::cout&lt;&lt;self(10);
}
</code></pre>

Trick here is that lambdas can access static variables and you can convert stateless ones to function pointer.

You can use it with standard lambdas:

<pre><code>void g()
{
 int sum;
 auto rec = [&amp;sum](int i) -&gt; int
 {
 static int (*inner)(int&amp;, int) = [](int&amp; _sum, int i)-&gt;int 
 {
 _sum += i;
 return i&gt;0 ? inner(_sum, i-1)*i : 1; 
 };
 return inner(sum, i);
 };
}
</code></pre>

Its work in GCC 4.7

blocks|key|1358796|text|这是定点运算符的一个稍微简单的实现，这使得它更明显，确切地说是发生了什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1358797|#include+<iostream>
#include+<functional>

using+namespace+std;

template<typename+T,+typename...+Args>
struct+fixpoint
{
++++typedef+function<T(Args...)>+effective_type;
++++typedef+function<T(const+effective_type&,+Args...)>+function_type;

++++function_type+f_nonr;

++++T+operator()(Args...+args)+const
++++{
++++++++return+f_nonr(*this,+args...);
++++}

++++fixpoint(const+function_type&+p_f)
++++++++:+f_nonr(p_f)
++++{
++++}
};


int+main()
{
++++auto+fib_nonr+=+[](const+function<int(int)>&+f,+int+n)+->+int
++++{
++++++++return+n+<+2+?+n+:+f(n-1)+%2B+f(n-2);
++++};

++++auto+fib+=+fixpoint<int,int>(fib_nonr);

++++for+(int+i+=+0;+i+<+6;+%2B%2Bi)
++++{
++++++++cout+<<+fib(i)+<<+'\n';
++++}
}|code-block|syntax|javascript|1358798|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|$]]

This is a slightly simpler implementation of the fixpoint operator which makes it a little more obvious exactly what's going on.

<pre><code>#include &lt;iostream&gt;
#include &lt;functional&gt;

using namespace std;

template&lt;typename T, typename... Args&gt;
struct fixpoint
{
 typedef function&lt;T(Args...)&gt; effective_type;
 typedef function&lt;T(const effective_type&amp;, Args...)&gt; function_type;

 function_type f_nonr;

 T operator()(Args... args) const
 {
 return f_nonr(*this, args...);
 }

 fixpoint(const function_type&amp; p_f)
 : f_nonr(p_f)
 {
 }
};


int main()
{
 auto fib_nonr = [](const function&lt;int(int)&gt;&amp; f, int n) -&gt; int
 {
 return n &lt; 2 ? n : f(n-1) + f(n-2);
 };

 auto fib = fixpoint&lt;int,int&gt;(fib_nonr);

 for (int i = 0; i &lt; 6; ++i)
 {
 cout &lt;&lt; fib(i) &lt;&lt; '\n';
 }
}
</code></pre>

blocks|key|1358827|text|这个答案不如Yankes的答案，但它仍然是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1358828|using+dp_type+=+void+(*)();

using+fp_type+=+void+(*)(dp_type,+unsigned,+unsigned);

fp_type+fp+=+[](dp_type+dp,+unsigned+const+a,+unsigned+const+b)+{
++::std::cout+<<+a+<<+::std::endl;
++return+reinterpret_cast<fp_type>(dp)(dp,+b,+a+%2B+b);
};

fp(reinterpret_cast<dp_type>(fp),+0,+1);|code-block|syntax|javascript|1358829|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|$]]

This answer is inferior to Yankes' one, but still, here it goes:

<pre><code>using dp_type = void (*)();

using fp_type = void (*)(dp_type, unsigned, unsigned);

fp_type fp = [](dp_type dp, unsigned const a, unsigned const b) {
 ::std::cout &lt;&lt; a &lt;&lt; ::std::endl;
 return reinterpret_cast&lt;fp_type&gt;(dp)(dp, b, a + b);
};

fp(reinterpret_cast&lt;dp_type&gt;(fp), 0, 1);
</code></pre>

blocks|key|1143780|text|有了C%2B%2B14，现在只需几行代码就可以很容易地创建一个高效的递归lambda，而不必产生std::function的额外开销：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1143781|template+<class+F>
struct+y_combinator+{
++++F+f;+//+the+lambda+will+be+stored+here
++++
++++//+a+forwarding+operator():
++++template+<class...+Args>
++++decltype(auto)+operator()(Args&&...+args)+const+{
++++++++//+we+pass+ourselves+to+f,+then+the+arguments.
++++++++return+f(*this,+std::forward<Args>(args)...);
++++}
};

//+helper+function+that+deduces+the+type+of+the+lambda:
template+<class+F>
y_combinator<std::decay_t<F>>+make_y_combinator(F&&+f)+{
++++return+{std::forward<F>(f)};
}|code-block|syntax|javascript|1143782|使用它，您的原始sum尝试将变成：|1143783|auto+sum+=+make_y_combinator([term,next](auto+sum,+int+a,+int+b)+{
++if+(a>b)+{
++++return+0;
++}
++else+{
++++return+term(a)+%2B+sum(next(a),b);
++}
});|1143784|1143785|在C%2B%2B17中，通过CTAD，我们可以添加一个扣减指南：|1143786|template+<class+F>+y_combinator(F)+->+y_combinator<F>;|1143787|这消除了对助手函数的需要。我们可以直接编写y_combinator{[](auto+self,+...){...}}。|1143788|1143789|在C%2B%2B20中，使用CTAD进行聚合，就不需要演绎指南了。|1143790|entityMap^0|18|D|0|0|8|3|0|0|0|0|0|L|11|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@]|D|@]|E|$]]|$1|R|3|S|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|Z|$]]

With C++14, it is now quite easy to make an efficient recursive lambda without having to incur the additional overhead of <code>std::function</code>, in just a few lines of code:
<pre class="lang-cpp prettyprint-override"><code>template &lt;class F&gt;
struct y_combinator {
 F f; // the lambda will be stored here
 
 // a forwarding operator():
 template &lt;class... Args&gt;
 decltype(auto) operator()(Args&amp;&amp;... args) const {
 // we pass ourselves to f, then the arguments.
 return f(*this, std::forward&lt;Args&gt;(args)...);
 }
};

// helper function that deduces the type of the lambda:
template &lt;class F&gt;
y_combinator&lt;std::decay_t&lt;F&gt;&gt; make_y_combinator(F&amp;&amp; f) {
 return {std::forward&lt;F&gt;(f)};
}
</code></pre>
with which your original <code>sum</code> attempt becomes:
<pre class="lang-cpp prettyprint-override"><code>auto sum = make_y_combinator([term,next](auto sum, int a, int b) {
 if (a&gt;b) {
 return 0;
 }
 else {
 return term(a) + sum(next(a),b);
 }
});
</code></pre>
<hr />
In C++17, with CTAD, we can add a deduction guide:
<pre class="lang-cpp prettyprint-override"><code>template &lt;class F&gt; y_combinator(F) -&gt; y_combinator&lt;F&gt;;
</code></pre>
Which obviates the need for the helper function. We can just write <code>y_combinator{[](auto self, ...){...}}</code> directly.
<hr />
In C++20, with CTAD for aggregates, the deduction guide won't be necessary.

blocks|key|1143866|text|要在不使用外部类和函数(如std::function或定点组合器)的情况下使lambda递归，可以在C%2B%2B14+(live+example)中使用以下结构：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1143867|#include+<utility>
#include+<list>
#include+<memory>
#include+<iostream>

int+main()
{
++++struct+tree
++++{
++++++++int+payload;
++++++++std::list<+tree+>+children+=+{};+//+std::list+of+incomplete+type+is+allowed
++++};
++++std::size_t+indent+=+0;
++++//+indication+of+result+type+here+is+essential
++++const+auto+print+=+[&]+(const+auto+&+self,+const+tree+&+node)+->+void
++++{
++++++++std::cout+<<+std::string(indent,+'+')+<<+node.payload+<<+'\n';
++++++++%2B%2Bindent;
++++++++for+(const+tree+&+t+:+node.children)+{
++++++++++++self(self,+t);
++++++++}
++++++++--indent;
++++};
++++print(print,+{1,+{{2,+{{8}}},+{3,+{{5,+{{7}}},+{6}}},+{4}}});
}|code-block|syntax|javascript|1143868|打印：|1143869|1
+2
++8
+3
++5
+++7
++6
+4|1143870|注意，lambda的结果类型应该显式指定。|1143871|entityMap|0|LINK|mutability|MUTABLE|url|https://wandbox.org/permlink/6Evvhrkuy9ONMs0g^0|D|D|1L|C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|17|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

To make lambda recursive without using external classes and functions (like <code>std::function</code> or fixed-point combinator) one can use the following construction in C++14 (<a href="https://wandbox.org/permlink/6Evvhrkuy9ONMs0g" rel="noreferrer">live example</a>):

<pre><code>#include &lt;utility&gt;
#include &lt;list&gt;
#include &lt;memory&gt;
#include &lt;iostream&gt;

int main()
{
 struct tree
 {
 int payload;
 std::list&lt; tree &gt; children = {}; // std::list of incomplete type is allowed
 };
 std::size_t indent = 0;
 // indication of result type here is essential
 const auto print = [&amp;] (const auto &amp; self, const tree &amp; node) -&gt; void
 {
 std::cout &lt;&lt; std::string(indent, ' ') &lt;&lt; node.payload &lt;&lt; '\n';
 ++indent;
 for (const tree &amp; t : node.children) {
 self(self, t);
 }
 --indent;
 };
 print(print, {1, {{2, {{8}}}, {3, {{5, {{7}}}, {6}}}, {4}}});
}
</code></pre>

prints:

<pre><code>1
 2
 8
 3
 5
 7
 6
 4
</code></pre>

Note, result type of lambda should be specified explicitly.

blocks|key|1143946|text|C%2B%2B+14:下面是一个递归的匿名无状态/无捕获泛型lambdas集，它输出从1到20的所有数字|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1143947|([](auto+f,+auto+n,+auto+m)+{
++++f(f,+n,+m);
})(
++++[](auto+f,+auto+n,+auto+m)+->+void
{
++++cout+<<+typeid(n).name()+<<+el;
++++cout+<<+n+<<+el;
++++if+(n<m)
++++++++f(f,+%2B%2Bn,+m);
},
++++1,+20);|code-block|syntax|javascript|1143948|如果我理解正确的话，这是在使用Y-combinator解决方案|1143949|这是sum(n，m)版本|1143950|auto+sum+=+[](auto+n,+auto+m)+{
++++return+([](auto+f,+auto+n,+auto+m)+{
++++++++int+res+=+f(f,+n,+m);
++++++++return+res;
++++})(
++++++++[](auto+f,+auto+n,+auto+m)+->+int
++++++++{
++++++++++++if+(n+>+m)
++++++++++++++++return+0;
++++++++++++else+{
++++++++++++++++int+sum+=+n+%2B+f(f,+n+%2B+1,+m);
++++++++++++++++return+sum;
++++++++++++}
++++++++},
++++++++n,+m);+};

auto+result+=+sum(1,+10);+//result+==+55|1143951|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

C++ 14:
Here is a recursive anonymous stateless/no capture generic set of lambdas
that outputs all numbers from 1, 20

<pre><code>([](auto f, auto n, auto m) {
 f(f, n, m);
})(
 [](auto f, auto n, auto m) -&gt; void
{
 cout &lt;&lt; typeid(n).name() &lt;&lt; el;
 cout &lt;&lt; n &lt;&lt; el;
 if (n&lt;m)
 f(f, ++n, m);
},
 1, 20);
</code></pre>

If I understand correctly this is using the Y-combinator solution

And here is the sum(n, m) version

<pre><code>auto sum = [](auto n, auto m) {
 return ([](auto f, auto n, auto m) {
 int res = f(f, n, m);
 return res;
 })(
 [](auto f, auto n, auto m) -&gt; int
 {
 if (n &gt; m)
 return 0;
 else {
 int sum = n + f(f, n + 1, m);
 return sum;
 }
 },
 n, m); };

auto result = sum(1, 10); //result == 55
</code></pre>

blocks|key|1359133|text|这里是基于@Barry提出的Y-combinator解决方案的改进版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1359134|template+<class+F>
struct+recursive+{
++F+f;
++template+<class...+Ts>
++decltype(auto)+operator()(Ts&&...+ts)++const+{+return+f(std::ref(*this),+std::forward<Ts>(ts)...);+}

++template+<class...+Ts>
++decltype(auto)+operator()(Ts&&...+ts)++{+return+f(std::ref(*this),+std::forward<Ts>(ts)...);+}
};

template+<class+F>+recursive(F)+->+recursive<F>;
auto+const+rec+=+[](auto+f){+return+recursive{std::move(f)};+};|code-block|syntax|javascript|1359135|要使用它，可以执行以下操作|1359136|auto+fib+=+rec([&](auto&&+fib,+int+i)+{
//+implementation+detail+omitted.
});|1359137|它与OCaml中的let+rec关键字相似，尽管不同。|offset|length|style|CODE|1359138|entityMap^0|0|0|0|0|9|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Here is a refined version of the Y-combinator solution based on one proposed by @Barry.

<pre class="lang-cpp prettyprint-override"><code>template &lt;class F&gt;
struct recursive {
 F f;
 template &lt;class... Ts&gt;
 decltype(auto) operator()(Ts&amp;&amp;... ts) const { return f(std::ref(*this), std::forward&lt;Ts&gt;(ts)...); }

 template &lt;class... Ts&gt;
 decltype(auto) operator()(Ts&amp;&amp;... ts) { return f(std::ref(*this), std::forward&lt;Ts&gt;(ts)...); }
};

template &lt;class F&gt; recursive(F) -&gt; recursive&lt;F&gt;;
auto const rec = [](auto f){ return recursive{std::move(f)}; };
</code></pre>

To use this, one could do the following

<pre class="lang-cpp prettyprint-override"><code>auto fib = rec([&amp;](auto&amp;&amp; fib, int i) {
// implementation detail omitted.
});
</code></pre>

It is similar to the <code>let rec</code> keyword in OCaml, although not the same.

I am new to C++11. I am writing the following recursive lambda function, but it doesn't compile.

<h1>sum.cpp</h1>

<pre><code>#include &lt;iostream&gt;
#include &lt;functional&gt;

auto term = [](int a)-&gt;int {
 return a*a;
};

auto next = [](int a)-&gt;int {
 return ++a;
};

auto sum = [term,next,&amp;sum](int a, int b)mutable -&gt;int {
 if(a&gt;b)
 return 0;
 else
 return term(a) + sum(next(a),b);
};

int main(){
 std::cout&lt;&lt;sum(1,10)&lt;&lt;std::endl;
 return 0;
}
</code></pre>

<h1>compilation error:</h1>

vimal@linux-718q:~/Study/09C++/c++0x/lambda> g++ -std=c++0x sum.cpp

sum.cpp: In lambda function:
sum.cpp:18:36: error: ‘<code>((&lt;lambda(int, int)&gt;*)this)-&gt;&lt;lambda(int, int)&gt;::sum</code>’ cannot be used as a function

<h1>gcc version</h1>

gcc version 4.5.0 20091231 (experimental) (GCC)

But if I change the declaration of <code>sum()</code> as below, it works:

<pre><code>std::function&lt;int(int,int)&gt; sum = [term,next,&amp;sum](int a, int b)-&gt;int {
 if(a&gt;b)
 return 0;
 else
 return term(a) + sum(next(a),b);
};
</code></pre>

Could someone please throw light on this?

Recursive lambda functions in C++11

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我是C++11的新手，我正在写下面的递归lambda函数，但是它不能编译。sum.cpp#include <iostream>#include <functional>auto term = [](int a)->int { return a*a;};auto next = [](int a)->int { ret...

问C++11中的递归lambda函数
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++11中的递归lambda函数EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++11中的递归lambda函数
EN