Answers:
C ++包括有用的通用函数,例如std::for_each
和std::transform
,可以非常方便。不幸的是,它们的使用也很麻烦,特别是如果您要应用的函子对于特定功能是唯一的。
#include <algorithm>
#include <vector>
namespace {
struct f {
void operator()(int) {
// do something
}
};
}
void func(std::vector<int>& v) {
f f;
std::for_each(v.begin(), v.end(), f);
}
如果您只f
在该特定位置使用一次,那么写一整堂课只是为了一件琐碎的事而已,这似乎是过高的选择。
在C ++ 03中,您可能会想编写类似以下内容的内容,以使函子保持本地化:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
但是这是不允许的,f
不能传递给C ++ 03中的模板函数。
C ++ 11引入了lambda,它使您可以编写内联匿名函子来代替struct f
。对于小的简单示例,这可能更易于阅读(将所有内容保存在一个地方),并且可能更易于维护(例如,以最简单的形式):
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Lambda函数只是匿名函子的语法糖。
在简单的情况下,可以为您推断出lambda的返回类型,例如:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
但是,当您开始编写更复杂的lambda时,您将很快遇到编译器无法推断返回类型的情况,例如:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
为了解决这个问题,您可以使用以下命令为lambda函数显式指定返回类型-> T
:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) -> double {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
到目前为止,除了在lambda中传递给lambda的东西之外,我们没有使用其他任何东西,但是我们也可以在lambda中使用其他变量。如果要访问其他变量,可以使用capture子句([]
表达式的),这些子句到目前为止在这些示例中尚未使用,例如:
void func5(std::vector<double>& v, const double& epsilon) {
std::transform(v.begin(), v.end(), v.begin(),
[epsilon](double d) -> double {
if (d < epsilon) {
return 0;
} else {
return d;
}
});
}
您可以同时通过引用和值进行捕获,可以分别使用&
和进行指定=
:
[&epsilon]
通过引用捕获[&]
通过引用捕获lambda中使用的所有变量[=]
按值捕获lambda中使用的所有变量[&, epsilon]
捕获与[&]类似的变量,但按值捕获epsilon[=, &epsilon]
捕获与[=]类似的变量,但通过引用捕获epsilon生成的operator()
是const
默认情况下,与暗示捕获会const
当你默认访问它们。这样的效果是,每个具有相同输入的调用将产生相同的结果,但是您可以将lambda标记为,mutable
以请求operator()
所产生的不是const
。
const
始终是...
()
-它作为零参数lambda传递,但是由于() const
与lambda不匹配,它会寻找允许它的类型转换,其中包括隐式转换功能指针,然后调用它!鬼!
std::function<double(int, bool)> f = [](int a, bool b) -> double { ... };
但是通常,我们让编译器推断类型:( auto f = [](int a, bool b) -> double { ... };
并且不要忘记#include <functional>
)
return d < 0.00001 ? 0 : d;
当一个操作数是整数常量时为什么保证返回双倍数(这是因为?:运算符的隐式提升规则,其中第二和第三操作数通过通常的算术相互平衡)转化,无论选择哪一个)。更改为0.0 : d
也许会使示例更容易理解。
Lambda函数的C ++概念起源于Lambda演算和函数式编程。Lambda是一个未命名的函数,对于无法重用且不值得命名的短代码片段很有用(在实际编程中,而不是理论上)。
在C ++中,lambda函数的定义如下:
[]() { } // barebone lambda
或全部荣耀
[]() mutable -> T { } // T is the return type, still lacking throw()
[]
是捕获列表,()
参数列表和{}
函数体。
捕获列表定义了lambda外部应该在函数体内提供哪些内容以及如何使用。可以是:
您可以在逗号分隔的列表中混合以上任何内容[x, &y]
。
参数列表与任何其他C ++函数相同。
实际调用lambda时将执行的代码。
如果lambda仅具有一个return语句,则可以省略返回类型,并且其隐式类型为decltype(return_statement)
。
如果将lambda标记为可变的(例如[]() mutable { }
),则可以对已通过值捕获的值进行突变。
ISO标准定义的库极大地受益于lambda,并提高了可用性,因为现在用户无需在某些可访问范围内使用小型函子来使代码混乱。
在C ++ 14中,lambda通过各种建议进行了扩展。
现在可以使用来初始化捕获列表的元素=
。这样可以重命名变量并通过移动来捕获。从标准中获取的示例:
int x = 4;
auto y = [&r = x, x = x+1]()->int {
r += 2;
return x+2;
}(); // Updates ::x to 6, and initializes y to 7.
以及摘自Wikipedia的其中一个演示了如何使用进行捕获std::move
:
auto ptr = std::make_unique<int>(10); // See below for std::make_unique
auto lambda = [ptr = std::move(ptr)] {return *ptr;};
Lambda现在可以是通用的(如果在周围范围内某处是类型模板参数,则auto
等同于T
此处
T
):
auto lambda = [](auto x, auto y) {return x + y;};
C ++ 14允许为每个函数推导返回类型,并且不将其限制为form的函数return expression;
。这也扩展到了lambda。
r = &x; r += 2;
,但发生这种情况的4.原始值
Lambda表达式通常用于封装算法,以便可以将它们传递给另一个函数。但是,可以在定义后立即执行lambda:
[&](){ ...your code... }(); // immediately executed lambda expression
在功能上等同于
{ ...your code... } // simple code block
这使lambda表达式成为重构复杂函数的强大工具。首先,将代码段包装在lambda函数中,如上所示。然后,可以在每个步骤之后通过中间测试逐步执行显式参数化的过程。将代码块完全参数化后(如删除所示&
),可以将代码移至外部位置并将其设为正常功能。
同样,您可以使用lambda表达式根据算法的结果来初始化变量 ...
int a = []( int b ){ int r=1; while (b>0) r*=b--; return r; }(5); // 5!
作为分区程序逻辑的一种方式,您甚至可能发现将lambda表达式作为参数传递给另一个lambda表达式很有用...
[&]( std::function<void()> algorithm ) // wrapper section
{
...your wrapper code...
algorithm();
...your wrapper code...
}
([&]() // algorithm section
{
...your algorithm code...
});
Lambda表达式还允许您创建命名的嵌套函数,这是避免重复逻辑的便捷方法。当将非平凡的函数作为参数传递给另一个函数时,使用命名的lambda往往也更容易(与匿名内联lambda相比)。 注意:不要忘了在大括号后加上分号。
auto algorithm = [&]( double x, double m, double b ) -> double
{
return m*x+b;
};
int a=algorithm(1,2,3), b=algorithm(4,5,6);
如果后续分析显示出该函数对象的大量初始化开销,则可以选择将其重写为普通函数。
if
陈述的一种争辩:if ([i]{ for (char j : i) if (!isspace(j)) return false ; return true ; }()) // i is all whitespace
假设i
是std::string
[](){}();
。
(lambda: None)()
语法更加清晰易读。
main() {{{{((([](){{}}())));}}}}
答案
问:C ++ 11中的lambda表达式是什么?
答:在后台,它是带有重载operator()const的自动生成类的对象。这种对象称为闭包,由编译器创建。这个“关闭”概念与C ++ 11的bind概念差不多。但是lambda通常会生成更好的代码。通过闭包的调用允许完整的内联。
问:我什么时候会用一次?
答:要定义“简单逻辑”,并要求编译器根据上一个问题进行生成。您为编译器提供了一些要包含在operator()中的表达式。所有其他的东西编译器都会为您生成。
问:在介绍之前,他们无法解决哪种问题?
答:这是一种语法糖,例如运算符重载,而不是自定义添加,子操作的函数……但是它节省了更多的不需要的代码行,可以将1-3行的实际逻辑包装到某些类中,等等!一些工程师认为,如果行数较少,那么出错的机会就更少了(我也这么认为)
使用例
auto x = [=](int arg1){printf("%i", arg1); };
void(*f)(int) = x;
f(1);
x(1);
有关lambda的其他内容,不在问题范围之内。如果您不感兴趣,请忽略此部分
1.捕获的值。您可以捕获什么
1.1。您可以使用lambdas引用具有静态存储持续时间的变量。他们全部被捕获。
1.2。您可以使用lambda来“按值”捕获值。在这种情况下,捕获的变量将被复制到函数对象(关闭)。
[captureVar1,captureVar2](int arg1){}
1.3。您可以参考。&-在本文中是指引用,而不是指针。
[&captureVar1,&captureVar2](int arg1){}
1.4。它具有表示法,可以按值或按引用捕获所有非静态变量
[=](int arg1){} // capture all not-static vars by value
[&](int arg1){} // capture all not-static vars by reference
1.5。它存在一种表示法,可以按值或按引用捕获所有非静态var并指定smth。更多。示例:通过值捕获所有非静态变量,但通过引用捕获Param2
[=,&Param2](int arg1){}
通过引用捕获所有非静态变量,但通过值捕获Param2
[&,Param2](int arg1){}
2.返回类型扣除
2.1。如果lambda是一个表达式,则可以推断出lambda返回类型。或者您可以显式指定它。
[=](int arg1)->trailing_return_type{return trailing_return_type();}
如果lambda具有多个表达式,则必须通过尾随返回类型指定返回类型。同样,类似的语法可以应用于自动功能和成员功能
3.捕获的值。您无法捕获的内容
3.1。您只能捕获本地var,而不能捕获对象的成员变量。
4.转换
4.1 !! Lambda不是函数指针,也不是匿名函数,但是可以将无捕获的 Lambda 隐式转换为函数指针。
ps
有关lambda语法信息的更多信息,请参见《 C ++编程语言》工作草案#337、2012-01-16、5.1.2。Lambda表达式,第88页
在C ++ 14中,添加了名为“初始捕获”的额外功能。它允许任意执行闭包数据成员的声明:
auto toFloat = [](int value) { return float(value);};
auto interpolate = [min = toFloat(0), max = toFloat(255)](int value)->float { return (value - min) / (max - min);};
[&,=Param2](int arg1){}
似乎不是有效的语法。正确的格式是[&,Param2](int arg1){}
Lambda函数是您直接创建的匿名函数。正如某些人所解释的,它可以捕获变量(例如,http : //www.stroustrup.com/C++11FAQ.html#lambda),但是存在一些限制。例如,如果有这样的回调接口,
void apply(void (*f)(int)) {
f(10);
f(20);
f(30);
}
您可以当场编写一个函数来使用它,就像下面传递的那样:
int col=0;
void output() {
apply([](int data) {
cout << data << ((++col % 10) ? ' ' : '\n');
});
}
但是您不能这样做:
void output(int n) {
int col=0;
apply([&col,n](int data) {
cout << data << ((++col % 10) ? ' ' : '\n');
});
}
由于C ++ 11标准的局限性。如果要使用捕获,则必须依赖库
#include <functional>
(或其他一些类似算法的STL库来间接获取它),然后使用std :: function而不是像这样将普通函数作为参数传递:
#include <functional>
void apply(std::function<void(int)> f) {
f(10);
f(20);
f(30);
}
void output(int width) {
int col;
apply([width,&col](int data) {
cout << data << ((++col % width) ? ' ' : '\n');
});
}
apply
是接受函子的模板,它将起作用
最好的解释之一lambda expression
是C ++的作者Bjarne Stroustrup在其书的***The C++ Programming Language***
第11章中给出的(ISBN-13:978-0321563842):
What is a lambda expression?
甲lambda表达式,有时也被称作拉姆达 函数或(严格地说不正确,但通俗),为 的λ,是用于定义和使用的简化表示法匿名功能对象。我们可以使用简写形式,而不是使用operator()定义命名的类,之后再创建该类的对象并最终调用它。
When would I use one?
当我们想将运算作为参数传递给算法时,这特别有用。在图形用户界面(和其他位置)的上下文中,此类操作通常称为回调。
What class of problem do they solve that wasn't possible prior to their introduction?
在这里,我猜想用lambda表达式完成的每个动作都可以在没有它们的情况下解决,但是需要更多的代码和更大的复杂性。Lambda表达式是优化代码的一种方法,也是使其更具吸引力的一种方法。由Stroustup感到悲伤:
优化的有效方法
Some examples
通过lambda表达式
void print_modulo(const vector<int>& v, ostream& os, int m) // output v[i] to os if v[i]%m==0
{
for_each(begin(v),end(v),
[&os,m](int x) {
if (x%m==0) os << x << '\n';
});
}
或通过功能
class Modulo_print {
ostream& os; // members to hold the capture list int m;
public:
Modulo_print(ostream& s, int mm) :os(s), m(mm) {}
void operator()(int x) const
{
if (x%m==0) os << x << '\n';
}
};
甚至
void print_modulo(const vector<int>& v, ostream& os, int m)
// output v[i] to os if v[i]%m==0
{
class Modulo_print {
ostream& os; // members to hold the capture list
int m;
public:
Modulo_print (ostream& s, int mm) :os(s), m(mm) {}
void operator()(int x) const
{
if (x%m==0) os << x << '\n';
}
};
for_each(begin(v),end(v),Modulo_print{os,m});
}
如果您需要,可以使用lambda expression
以下名称:
void print_modulo(const vector<int>& v, ostream& os, int m)
// output v[i] to os if v[i]%m==0
{
auto Modulo_print = [&os,m] (int x) { if (x%m==0) os << x << '\n'; };
for_each(begin(v),end(v),Modulo_print);
}
或假设另一个简单的样本
void TestFunctions::simpleLambda() {
bool sensitive = true;
std::vector<int> v = std::vector<int>({1,33,3,4,5,6,7});
sort(v.begin(),v.end(),
[sensitive](int x, int y) {
printf("\n%i\n", x < y);
return sensitive ? x < y : abs(x) < abs(y);
});
printf("sorted");
for_each(v.begin(), v.end(),
[](int x) {
printf("x - %i;", x);
}
);
}
会产生下一个
0
1个
0
1个
0
1个
0
1个
0
1个
0已排序x-1; x-3; x-4; x-5; x-6; x-7; x-33;
[]
-这是捕获列表或lambda introducer
:如果lambdas
不需要访问其本地环境,我们可以使用它。
书中引用:
Lambda表达式的第一个字符始终为[。Lambda引入程序可以采用多种形式:
• []:一个空的捕获列表。这意味着在lambda主体中不能使用来自周围上下文的本地名称。对于此类lambda表达式,数据是从参数或非局部变量获取的。
• [&]:通过引用隐式捕获。可以使用所有本地名称。通过引用访问所有局部变量。
• [=]:按值隐式捕获。可以使用所有本地名称。所有名称均引用在lambda表达式调用时获取的局部变量的副本。
• [捕获列表]: 显式捕获;capture-list是通过引用或值要捕获(即,存储在对象中)的局部变量名称的列表。名称以&开头的变量被引用捕获。其他变量按值捕获。捕获列表也可以包含此名称和名称,后跟...作为元素。
• [&,capture-list]:通过引用隐式捕获名称未在列表中提及的所有局部变量。捕获列表可以包含此列表。列出的名称不能以&开头。捕获列表中命名的变量按值捕获。
• [=,捕获列表]:按值隐式捕获列表中未提及名称的所有局部变量。捕获列表不能包含此内容。列出的名称必须以&开头。捕获列表中命名的变量通过引用捕获。
请注意,以&开头的本地名称始终由引用捕获,而不以&开头的本地名称始终由值捕获。只有通过引用捕获才能在调用环境中修改变量。
Additional
Lambda expression
格式
其他参考:
for (int x : v) { if (x % m == 0) os << x << '\n';}
好吧,我发现的一种实际用途是减少样板代码。例如:
void process_z_vec(vector<int>& vec)
{
auto print_2d = [](const vector<int>& board, int bsize)
{
for(int i = 0; i<bsize; i++)
{
for(int j=0; j<bsize; j++)
{
cout << board[bsize*i+j] << " ";
}
cout << "\n";
}
};
// Do sth with the vec.
print_2d(vec,x_size);
// Do sth else with the vec.
print_2d(vec,y_size);
//...
}
没有lambda,您可能需要针对不同的bsize
情况做一些事情。当然,您可以创建一个函数,但是如果您想在灵魂用户函数的范围内限制使用该怎么办?lambda的性质满足了此要求,在这种情况下,我会使用它。
c ++中的lambda被视为“运行中可用函数”。是的,您可以随时随地定义它;用它; 当父函数作用域完成时,lambda函数不见了。
c ++在c ++ 11中引入了它,每个人都像在每个可能的地方一样开始使用它。该示例以及什么是lambda可以在这里找到https://en.cppreference.com/w/cpp/language/lambda
我将描述每个C ++程序员都不知道的哪些是必不可少的
Lambda并不是要在所有地方使用,并且不能用lambda代替每个函数。与正常功能相比,它也不是最快的一种。因为它有一些开销,需要由lambda处理。
在某些情况下,它肯定会有助于减少行数。它基本上可以用于代码段,该段代码在同一函数中被调用一次或多次,并且该代码段在其他任何地方都不需要,因此您可以为其创建独立的函数。
以下是lambda的基本示例以及背景情况。
用户代码:
int main()
{
// Lambda & auto
int member=10;
auto endGame = [=](int a, int b){ return a+b+member;};
endGame(4,5);
return 0;
}
编译如何扩展它:
int main()
{
int member = 10;
class __lambda_6_18
{
int member;
public:
inline /*constexpr */ int operator()(int a, int b) const
{
return a + b + member;
}
public: __lambda_6_18(int _member)
: member{_member}
{}
};
__lambda_6_18 endGame = __lambda_6_18{member};
endGame.operator()(4, 5);
return 0;
}
如您所见,使用时会增加什么样的开销。因此在任何地方使用它们并不是一个好主意。它可以在适用的地方使用。
它解决的一个问题: 在构造函数中使用输出参数函数初始化const成员的调用的代码比lambda更简单
您可以通过调用一个函数来初始化类的const成员,该函数通过将其输出作为输出参数返回来设置其值。