我是c++ 11的新手。我正在写下面的递归lambda函数，但它不能编译。
sum.cpp
#include <iostream>
#include <functional>
auto term = [](int a)->int {
return a*a;
};
auto next = [](int a)->int {
return ++a;
};
auto sum = [term,next,&sum](int a, int b)mutable ->int {
if(a>b)
return 0;
else
return term(a) + sum(next(a),b);
};
int main(){
std::cout<<sum(1,10)<<std::endl;
return 0;
}
编译错误:
vimal@linux-718q：~/Study/09C++/c++0x/lambda> g++ -std=c++0x sum.cpp
sum.cpp:在lambda函数中
sum.cpp:18:36:错误:' ((<lambda(int, int)>*)this)-><lambda(int, int)>::sum '不能用作函数
gcc版本
gcc版本4.5.0 20091231(实验性)(gcc)
但如果我改变sum()的声明如下所示，它可以工作:
std::function<int(int,int)> sum = [term,next,&sum](int a, int b)->int {
if(a>b)
return 0;
else
return term(a) + sum(next(a),b);
};
有人能解释一下吗?
你需要一个不动点组合器。看到这个。
或者看看下面的代码:
//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;
}
考虑一下自动版本和完全指定类型版本之间的区别。auto关键字从初始化它的对象推断它的类型，但是初始化它的对象需要知道它的类型(在本例中，lambda闭包需要知道它捕获的类型)。有点像鸡生蛋还是蛋生鸡的问题。
另一方面，完全指定的函数对象的类型不需要“知道”任何被赋值给它的内容，因此lambda闭包同样可以完全知道它捕获的类型。
考虑一下对代码的轻微修改，它可能更有意义:
std::function<int(int, int)> sum;
sum = [term, next, &sum](int a, int b) -> int {
if (a > b)
return 0;
else
return term(a) + sum(next(a), b);
};
显然，这在auto中行不通。递归lambda函数工作得非常好(至少它们在MSVC中是这样的，我在MSVC中有使用它们的经验)，只是它们与类型推断并不真正兼容。
我使用std::function<>捕获方法运行了一个基准测试，比较递归函数和递归lambda函数。在clang版本4.1上启用了完全优化后，lambda版本的运行速度明显变慢了。
#include <iostream>
#include <functional>
#include <chrono>
uint64_t sum1(int n) {
return (n <= 1) ? 1 : n + sum1(n - 1);
}
std::function<uint64_t(int)> sum2 = [&] (int n) {
return (n <= 1) ? 1 : n + sum2(n - 1);
};
auto const ITERATIONS = 10000;
auto const DEPTH = 100000;
template <class Func, class Input>
void benchmark(Func&& func, Input&& input) {
auto t1 = std::chrono::high_resolution_clock::now();
for (auto i = 0; i != ITERATIONS; ++i) {
func(input);
}
auto t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count();
std::cout << "Duration: " << duration << std::endl;
}
int main() {
benchmark(sum1, DEPTH);
benchmark(sum2, DEPTH);
}
产生的结果:
Duration: 0 // regular function
Duration: 4027 // lambda function
(注意:我还确认了一个从cin获取输入的版本，以消除编译时计算)
Clang还会产生一个编译器警告:
main.cc:10:29: warning: variable 'sum2' is uninitialized when used within its own initialization [-Wuninitialized]
这是意料之中的，也是安全的，但应该注意。
在我们的工具中有一个解决方案是很好的，但我认为如果要与当前的方法相比，该语言需要更好的方法来处理这种情况。
注意:
正如一位评论者指出的那样，最新版本的vc++似乎已经找到了一种方法来优化这一点，以达到同等的性能。也许我们不需要更好的方法来处理这个问题(除了语法糖)。
另外，正如最近几周其他一些SO帖子所概述的那样，std::function<>本身的性能可能是导致直接调用function速度变慢的原因，至少当lambda捕获太大而无法放入一些库优化的空间时(我猜有点像各种短字符串优化?)
