什么是C++ 11中的lambda表达式？我什么时候用？他们解决了哪些问题在引入之前是不可能的？
一些示例和用例将是有用的.
感谢C++ 11,我们收到了std::functionfunctor包装器系列.不幸的是,我一直只听到关于这些新增内容的不好的事情.最受欢迎的是它们非常慢.我对它进行了测试,与模板相比,它们真的很糟糕.
#include <iostream>
#include <functional>
#include <string>
#include <chrono>
template <typename F>
float calc1(F f) { return -1.0f * f(3.3f) + 666.0f; }
float calc2(std::function<float(float)> f) { return -1.0f * f(3.3f) + 666.0f; }
int main() {
using namespace std::chrono;
const auto tp1 = system_clock::now();
for (int i = 0; i < 1e8; ++i) {
calc1([](float arg){ return arg * 0.5f; });
}
const auto tp2 = high_resolution_clock::now();
const auto d = duration_cast<milliseconds>(tp2 - tp1);
std::cout << …可能重复:
c ++ 0x中的递归lambda函数
这是一个普通的旧递归函数:
int fak(int n)
{
return (n <= 1) ? 1 : n * fak(n - 1);
}
我如何编写像lambda函数这样的递归函数？
[](int n) { return (n <= 1) ? 1 : n * operator()(n - 1); }
// error: operator() not defined
[](int n) { return (n <= 1) ? 1 : n * (*this)(n - 1); }
// error: this wasn't captured for this lambda function
是否有任何表达当前lambda的表达式,因此它可以递归调用自身？
我试图弄清楚如何在自身中获取lambda函数的地址。这是一个示例代码：
[]() {
std::cout << "Address of this lambda function is => " << ????
}();
我知道我可以在变量中捕获lambda并打印地址，但是我想在执行此匿名函数时就地执行此操作。
有没有更简单的方法？
在C++ 11中编写递归lambda函数有一个经常重复的"技巧",如下所示:
std::function<int(int)> factorial;
factorial = [&factorial](int n)
{ return n < 2 ? 1 : n * factorial(n - 1); };
assert( factorial(5) == 120 );
(例如,C++ 0x中的递归lambda函数.)
这种技术有两个直接的缺点:std::function<Sig>对象的目标(通过引用捕获)与非常特定的std::function<Sig>对象(此处factorial)相关联.这意味着通常无法从函数返回生成的仿函数,否则引用将保持悬空状态.
另一个(尽管不那么直接)问题是使用std::function通常会阻止编译器优化,这是在其实现中需要类型擦除的副作用.这不是假设,可以很容易地进行测试.
在假设的情况下,递归lambda表达式真的很方便,有没有办法解决这些问题？
可能重复:
c ++ 0x中的递归lambda函数
如果我把它写成:为什么我不能递归地调用lambda:
auto a = [&]
{
static int i = 0; i++;
std::cout << i << std::endl;
if (i<10)
a(); //recursive call
};
它给出了编译错误(ideone):
prog.cpp:8:18: error: '((const main()::<lambda()>*)this)->main()::<lambda()>::a' cannot be used as a function
prog.cpp: In function 'int main()':
prog.cpp:9:9: error: variable 'auto a' with 'auto' type used in its own initializer
错误是什么意思？
我理解为什么我不能写这个:
auto i=i+1; //error: unable to deduce 'auto' from '<expression error>'
我们不能写这个,因为i必须从它的初始化推断出类型,这意味着如果i自身出现在初始化(ideone)中,则无法推断出类型.但是,如果是lambda,它又如何重要？如果我没错,lambda的类型由它的参数和返回类型决定; 它不依赖于身体,如果它什么都不返回(在这种情况下,返回类型被推断为void,无论lambda体中的其他语句如何). …
我已经搜索了引用和一般网络,但我无法找到,如果它存在.
有没有办法在C++中获取指向当前函数的指针？它是如此微不足道,它应该存在.
在完美的世界中,我想找到一种获得std::function当前函数的方法,但即使是旧式指针也可以.
澄清为什么可能需要它:我正在考虑Lambda函数内部的递归,甚至是函数中的一般递归,在将来的版本中,名称更改的可能性很大.
与常规递归函数相比,递归lambda函数是否会引发任何开销(因为我们必须将它们捕获到std :: function中)？
这个函数与仅使用常规函数的类似函数有什么区别？
int main(int argc, const char *argv[])
{
std::function<void (int)> helloworld = [&helloworld](int count) {
std::cout << "Hello world" << std::endl;
if (count > 1) helloworld(--count);
};
helloworld(2);
return 0;
}
最近，我阅读了Barry对这个问题Recursive lambda functions in C++11的回答：
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.
// [edit: Barry] pass in std::ref(*this) instead of *this
return f(std::ref(*this), std::forward<Args>(args)...);
}
};
// deduction guide
template <class F> y_combinator(F) -> y_combinator<F>;
基本上，y_combinator允许更轻松地编写递归 lambda 表达式（例如，无需 delcare a std::function）。当我玩的时候y_combinator，我发现了一些奇怪的东西： …
我想捕捉一个"参考"的拉姆达,我认为,一个函数指针会做的伎俩,如:
int (*factorial)(int) = [&](int x){
return (x < 2)
? 1
: x * factorial(x - 1);
};
但我明白了cannot convert from main::lambda<......> to int(_cdecl *)(int).
那么指向lambda的正确方法是什么？