广告公司怎么设置网站关键字/东莞疫情最新消息今天新增病例

lambda表达式概念

lambda 表达式是 c++11 中引入的一种匿名函数，它可以在需要函数对象的地方使用，可以用作函数参数或返回值。lambda 表达式可以看作是一种局部定义的函数对象，它通常用于简化代码或实现某些特定的功能。

接下来我们举一个例子来说明为什么需要 lambda 表达式：

商品类 Goods 的定义：

struct Goods
{string _name;  // 名字double _price; // 价格int _count;    // 数量
};

现在，我们需要对若干商品分别按照价格和数量进行升序、降序排序。

想要对一个数据集合中的元素进行排序，可以使用 sort 函数，但是这里的待排序元素是自定义类型，因此需要用户自定义排序的比较规则。控制 sort 函数的比较方式通常有两种方法：1. 对商品类的 () 运算符进行重载； 2. 通过仿函数指定比较方式。

下面使用仿函数的方式来完成上述的排序：

struct Goods
{Goods(const char* str, double price, int count):_name(str),_price(price),_count(count){}string _name;double _price;int _count;
};struct ComparePriceLess
{bool operator()(const Goods& gl, const Goods& gr){return gl._price < gr._price;}
};struct ComparePriceGreater
{bool operator()(const Goods& gl, const Goods& gr){return gl._price > gr._price;}
};struct CompareNumLess
{bool operator()(const Goods& gl, const Goods& gr){return gl._count < gr._count;}
};struct CompareNumGreater
{bool operator()(const Goods& gl, const Goods& gr){return gl._count > gr._count;}
};int main()
{vector<Goods> v = { { "苹果", 2.1, 50 }, { "香蕉", 3, 40 }, { "草莓", 2.2,30 }, { "菠萝", 1.5, 40 },{"芒果",2.5,120} };sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater());sort(v.begin(), v.end(), CompareNumLess());      sort(v.begin(), v.end(), CompareNumGreater()); 
}

使用仿函数可以解决自定义类型的排序问题，在大型项目中，有可能仿函数的定义位置和使用仿函数的位置可能会相隔很远，所以仿函数的命令必须要通俗易懂，否则会降低代码的可读性和可维护性。

随着 c++ 语法的发展，人们觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法，都需要重新去写一个类，如果每次比较的逻辑不一样，还需要去实现多个类，特别是相同类的命名。因此，c++11 中出现了 lambda 表达式。

使用 lambda 表达式完成上面要求，如下：

struct Goods
{Goods(const char* str, double price, int count):_name(str),_price(price),_count(count){}string _name;double _price;int _count;
};int main()
{vector<Goods> v = { { "苹果", 2.1, 50 }, { "香蕉", 3, 40 }, { "草莓", 2.2,30 }, { "菠萝", 1.5, 40 },{"芒果",2.5,120} };sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._count < g2._count;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._count > g2._count;});
}

在这个代码示例中，使用 lambda 表达式作为 sort 函数的第三个参数，可以方便地根据不同的排序标准对 vector 中的 Goods 对象进行排序，而不需要单独定义多个比较函数。这样可以减少代码量和提高代码的可读性，同时节省定义函数的时间和空间开销。

lambda表达式语法

lambda 表达式的书写格式：[capture-list] (parameters) mutable -> return-type { statement }

• [capture-list]：捕捉列表，该列表位于 lambda 函数的开始位置，编译器根据 [] 来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。
• (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同 () 一起省略。
• mutable：默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性。使用该修饰符时，参数列表不可省略（即使参数为空）。
• returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}：函数体。在该函数体内，处理可以使用其参数外，还可以使用所有捕获到的变量。

注意：在 lambda 函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此，c++11 中最简单的 lambda 函数为：[]{}：但该 lambda 函数不能做任何事情。

🎊捕捉列表说明：捕捉列表描述了上下文中哪些数据可以被 lambda 使用，以及使用的方式传值还是传引用。

• [var]：表示使用值传递的方式捕捉变量 var。
• [=]：表示使用值传递的方式捕捉所有父作用域中的变量（包括 this）。
• [&var]：表示使用引用传递捕捉变量 var。
• [&]：表示使用引用传递捕捉所有父作用域中的变量（包括 this）。
• [this]：表示使用值传递方式捕捉当前的 this 指针。

说明：

• 父作用域指包含 lambda 函数的语句块。
• 语法上捕捉列表可由多个捕捉项组成，并以逗号分隔。 如：[=,&a,&b] 以引用传递的方式捕捉变量 a 和 b，指传递方式捕捉其它所有变量，[&,a,this] 值传递方式捕捉变量 a 和 this，引用方式捕捉其它变量。
• 捕捉列表不允许变量重复传递，否则会导致编译报错。 如：[=,a]：= 已经以值传递方式捕捉了所有变量，捕捉 a 重复了。
• 在块作用域以外的 lambda 函数捕捉列表必须为空。
• 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
• lambda 表达式之间不能相互赋值，即使看起来类型相同。

lambda 表达式使用示例：

int main()
{// 最简单的lambda表达式，该lambda表达式没有任何意义[] {};// 省略参数列表和返回值类型，返回值类型由编译器推导为intint a = 4, b = 7;[=] {return a + b;};// 省略了返回值类型，无返回值类型auto func1 = [&](int c) {b = a + c;};func1(12);cout << a << " : " << b << endl;// 各部分都完善的lambda函数auto func2 = [=, &b](int c)->int {return b += a + c;};cout << func2(45) << endl;// 复制捕捉xint x = 5;auto add_x = [x](int a) mutable {x *= 2;return a + x;};cout << add_x(10) << endl;return 0;
}

以下代码演示了 lambda 函数的拷贝构造以及如何将 lambda 表达式赋值给函数指针：

void (*pfunc)();int main()
{auto f1 = [] {cout << "lambda" << endl;};auto f2 = [] {cout << "lambda" << endl;};// f1 = f2; // 编译失败，提示找不到operator=()// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();// 可以将lambda表达式赋值给相同类型的函数指针pfunc = f2;pfunc();return 0;
}

函数对象与lambda表达式

函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了 operator() 运算符的对象。

如下所示，分别使用函数对象和 lambda 表达式实现计算利息：

class Rate
{
public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}
private:double _rate;
};int main()
{// 函数对象double rate = 0.49;Rate r1(rate);r1(10000, 2);// lambdaauto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);return 0;
}

从使用方式来说，函数对象和 lambda 表达式一样。函数对象以 rate 作为其成员变量，在定义对象时给出初始值即可，lambda 表达式通过捕获列表可以直接对该变量进行捕获。

实际在底层编译器对于 lambda 表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个 lambda 表达式，编译器会自动生成一个类，在该类中重载了 operator() 函数。

lambda 表达式的优势有：

• 使代码更加简洁，易读和易于维护。
• 可以捕获外部变量，使得 lambda 表达式更加灵活。
• 可以作为函数对象传递，使得函数式编程更加方便。