122.lambda表达式

1.Lambda表达式概述

Lambda表达式是现代C++在C++11和更高版本中的一个新的语法糖，在C++11、C++14、C++17和C++20中Lambda表达的内容还在不断更新。lambda表达式（也称为lambda函数）是在调用或作为函数参数传递的位置处定义匿名函数对象的便捷方法。通常，lambda用于封装传递给算法或异步方法的几行代码。本文主要介绍Lambda的工作原理以及使用方法。

2.Lambda表达式定义

2.1Lambda表达式示例

Lambda有很多叫法，有Lambda表达式、Lambda函数、匿名函数，本文中为了方便表述统一用Lambda表达式进行叙述。 ISO C++标准官网展示了一个简单的lambda表示式实例：

#include <algorithm>
#include <cmath>

void abssort(float* x, unsigned n) 
{
    std::sort(x, x + n,
        // Lambda expression begins
        [](float a, float b) 
        {
            return (std::abs(a) < std::abs(b));
        } // end of lambda expression
    );
}

在上面的实例中std::sort函数第三个参数应该是传递一个排序规则的函数，但是这个实例中直接将排序函数的实现写在应该传递函数的位置，省去了定义排序函数的过程，对于这种不需要复用，且短小的函数，直接传递函数体可以增加代码的可读性。

2.2Lambda表达式语法定义

捕获列表。在C++规范中也称为Lambda导入器，捕获列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数，捕获列表能够捕捉上下文中的变量以供Lambda函数使用。
参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号“()”一起省略。
可变规格。mutable修饰符，默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
异常说明。用于Lamdba表达式内部函数抛出异常。
返回类型。追踪返回类型形式声明函数的返回类型。我们可以在不需要返回值的时候也可以连同符号”->”一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
lambda函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。
必须永远包含捕获列表和函数体
与普通函数不同，lambda必须返回位置指针来返回类型

3.Lambda表达式参数详解

3.1Lambda捕获列表

void biggies(vector<string>& words, vector<string>::size_type sz)
{
    elimDups(words);//将words按字典序排序，删除重复单词
    //按长度排序，长度相同的单词维持字典序
    stable_sort(words.begin(), words.end(),
        [](const string& a, const string& b)
        {return a.size() < b.size();});

    //获取一个迭代器，指向第一个满足size()>=的元素
    auto wc = find_if(words.begin(), words.end(),
        [sz](const string& a)
        {return a.size() >= sz; });

    //计算满足size()>=sz的元素的数目
    auto count = words.end() - wc;
    cout << count << " " << make_plura; (count, "word", "s")
        << " of length " << sz << " or longer" << endl;

    //打印长度大于等于给定值的单词，每个单词后面接一个空格

    for_each(wc, words.end(),
        [](const string& s) {cout << s << " "; });

    cout << endl;
}

Lambda表达式与普通函数最大的区别是，除了可以使用参数以外，Lambda函数还可以通过捕获列表访问一些上下文中的数据。具体地，捕捉列表描述了上下文中哪些数据可以被Lambda使用，以及使用方式（以值传递的方式或引用传递的方式）。语法上，在“[]”包括起来的是捕获列表，捕获列表由多个捕获项组成，并以逗号分隔。捕获列表有以下几种形式：

[]表示不捕获任何变量。lambda不能使用所在函数中的变量。一个lambda只有捕获变量后才能使用它们

auto function = ( [] {std::cout << "Hello World!" << std::endl; } );

function();

void biggies(vector<string>& words, vector<string>::size_type sz)
{
    //按长度排序，长度相同的单词维持字典序
    stable_sort(words.begin(), words.end(),
        [](const string& a, const string& b)
        {return a.size() < b.size();});
}

[var]表示值传递方式捕获变量var，同时不捕获其他变量。也可能是一个逗号分隔的名字列表，这些名字都是lambda所在函数的局部变量。默认情况下，捕获列表中的变量都被拷贝。名字前如果使用了&，则采用引用捕获方式

void biggies(vector<string>& words, vector<string>::size_type sz)
{
    //获取一个迭代器，指向第一个满足size()>=的元素
    auto wc = find_if(words.begin(), words.end(),
        [sz](const string& a)
        {return a.size() >= sz; });
}

int num = 100;
auto function = ( [num] {std::cout << num << std::endl;} );

function();

void fcn1()
{
	size_t v1 = 42;  // local variable
	// copies v1 into the callable object named f
	auto f = [v1] { return v1; };
	v1 = 0;
	auto j = f(); // j is 42; f stored a copy of v1 when we created it
	cout << j << endl;
}

[=]表示值传递方式捕获所有父作用域的变量（包括this），并作为副本在函数体中使用（按值捕获）。隐式捕获列表，采用值捕获方式。lambda体将拷贝所使用的来自所在函数的实体的值

void biggies(vector<string>& words, vector<string>::size_type sz)
{    
    auto wc = find_if(words.begin(), words.end(),
        [=](const string& a)
        {return a.size() >= sz; });
}

int index = 1;
int num = 100;
auto function = ( [=] { std::cout << "index: " << index << ", " << "num: " << num << std::endl; } );

function();

#include <iostream>
#include <string>
using namespace std;

class Date
{
private:
    int _year;
    int _month;
    int _day;

public:
    Date(int y, int m, int d) :_year(y), _month(m), _day(d) {}
    void showDate()
    {
        string s = "Today is ";
        auto show = [=]() 
        {
            cout << s << this->_year << " : " << this->_month << " : " << this->_day << endl;
        };
        show();
    }
};

int main()
{
    Date d(2020, 7, 4);
    d.showDate();
    return 0;
}

注意：如果不使用=来捕捉，必须将this传进Lambda表达式中，要不然会报以下错误

 error: ‘this’ was not captured for this lambda function

[&var]表示引用传递捕获变量var 。隐式捕获列表，采用引用捕获方式。lambda体中所使用的来自所在函数的实体都采用引用方式使用。

int num = 100;
auto function = 
([&num] 
	{
		num = 1000;
		std::cout << "num: " << num << std::endl;
	}
);

function();

void fcn1()
{
    size_t v1 = 42;//局部变量
    //将vl拷贝到名为f的可调用对象
    auto f = [v1] { return v1; };
    v1 = 0;
    auto j = f();//j为42; f保存了我们创建它时v1的拷贝
}

[&]表示引用传递方式捕获所有父作用域的变量（包括this）

int index = 1;
int num = 100;
auto function = 
([&] 
	{
		num = 1000;
		index = 2;
		std::cout << "index: " << index << ", "
		<< "num: " << num << std::endl;
	}
);

function();

[this]表示值传递方式捕捉当前的this指针

#include <iostream>
using namespace std;

class Lambda
{
public:
    void sayHello() 
    {
        std::cout << "Hello" << std::endl;
    };

    void lambda() 
    {
        auto function = [this]
        {
            this->sayHello();
        };

        function();
    }
};

int main()
{
    Lambda demo;
    demo.lambda();
}

[=, &]

拷贝与引用混合
- [=, &a, &b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量。

int index = 1;
int num = 100;
auto function = 
([=, &index, &num] 
	{
		num = 1000;
		index = 2;
		std::cout << "index: " << index << ", "
		<< "num: " << num << std::endl;
	}
);

function();

void biggies(vector<string>& words, vector<string>::size_type sz, ostream &os = cout, char c = ' ')
{
    //os显示捕获，引用捕获方式；c隐式捕获，值捕获方式
    for_each(words.begin(), words.end(),
        [=, &os](const string& s) {os << s << c; });
}

[&, val]表示以值传递的方式捕获变量val，引用传递方式捕获其它所有变量。

void biggies(vector<string>& words, vector<string>::size_type sz, ostream &os = cout, char c = ' ')
{
    //os隐式捕获，引用捕获方式；c显式捕获，值捕获方式
    for_each(word.begin(), words.ends().end,
        [&, c](const string& s) {os << s << c; });
}

[&, a, this]表示以值传递的方式捕获变量a和this，引用传递方式捕捉其它所有变量。

不过值得注意的是，捕捉列表不允许变量重复传递。下面一些例子就是典型的重复，会导致编译时期的错误。例如：

[=,a]这里已经以值传递方式捕捉了所有变量，但是重复捕捉a了，会报错的；
[&,&this]这里&已经以引用传递方式捕捉了所有变量，再捕捉this也是一种重复。

如果Lambda主体total通过引用访问外部变量，并factor通过值访问外部变量，则以下捕获子句是等效的：

[&total, factor]
[factor, &total]
[&, factor]
[factor, &]
[=, &total]
[&total, =]

3.2Lambda参数列表

除了捕获列表之外，Lambda还可以接受输入参数。参数列表是可选的，并且在大多数方面类似于函数的参数列表。

auto function = [] (int first, int second){
    return first + second;
};
	
function(100, 200);

3.3可变规格mutable

mutable修饰符，默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。

#include <iostream>
using namespace std;

int main()
{
   int m = 0;
   int n = 0;
   [&, n] (int a) mutable { m = ++n + a; }(4);
   cout << m << endl << n << endl;
}

输出：

5
0

3.4异常说明

你可以使用 throw() 异常规范来指示 Lambda 表达式不会引发任何异常。与普通函数一样，如果 Lambda 表达式声明 C4297 异常规范且 Lambda 体引发异常，Visual C++ 编译器将生成警告 throw() 。

int main() // C4297 expected 
{ 
 	[]() throw() { throw 5; }(); 
}

在MSDN的异常规范中，明确指出异常规范是在 C++11 中弃用的 C++ 语言功能。因此这里不建议不建议大家使用。

3.5返回类型

Lambda表达式的返回类型会自动推导。除非你指定了返回类型，否则不必使用关键字。返回型类似于通常的方法或函数的返回型部分。但是，返回类型必须在参数列表之后，并且必须在返回类型->之前包含类型关键字。如果Lambda主体仅包含一个return语句或该表达式未返回值，则可以省略Lambda表达式的return-type部分。如果Lambda主体包含一个return语句，则编译器将从return表达式的类型中推断出return类型。否则，编译器将返回类型推导为void。

auto x1 = [](int i){ return i; };

默认情况下，如果一个lambda体包含return之外的任何语句，则编译器假定此lambda返回void。与其他返回void的函数类似，被推断返回 void的lambda不能返回值。

下面给出了一个简单的例子，我们可以使用标准库transform算法和一个lambda来将一个序列中的每个负数替换为其绝对值：

transform(vi.begin(), vi.end(), vi.begin(),
	[] (int i) { return i < 0 ? -i : i; ));

函数transforrn接受三个迭代器和一个可调用对象。前两个迭代器表示输入序列，第三个迭代器表示目的位置。算法对输入序列中每个元素调用可调用对象，并将结果写到目的位置。如本例所示，目的位置迭代器与表示输入序列开始位置的迭代器可以是相同的。当输入迭代器和目的迭代器相同时，transform将输入序列中每个元素替换为可调用对象操作该元素得到的结果。

在本例中，我们传递给transform一个lambda，它返回其参数的绝对值。lambda体是单一的return语句，返回一个条件表达式的结果。我们无须指定返回类型，因为可以根据条件运算符的类型推断出来。

但是，如果我们将程序改写为看起来是等价的if语句，就会产生编译错误：

transform(vi.begin(), vi.end(), vi.begin(),
	[](int i) {if (i < 0) return -i; else return i; });

编译器推断这个版本的lambda返回类型为void，但它返回了一个int值。

当我们需要为一个lambda定义返回类型时，必须使用尾置返回类型

transform(vi.begin(), vi.end(), vi.begin(),
	[](int i)->int
	{if (i < 0) return -i; else return i;});

在此例中，传递给transform的第四个参数是一个lambda，它的捕获列表是空的，接受单一int参数，返回一个返回其参数的绝对值的if语句。

3.6Lambda函数体

Lambda表达式的Lambda主体（标准语法中的复合语句）可以包含普通方法或函数的主体可以包含的任何内容。普通函数和Lambda表达式的主体都可以访问以下类型的变量：

捕获变量
形参变量
局部声明的变量
类数据成员，当在类内声明this并被捕获时
具有静态存储持续时间的任何变量，例如全局变量

#include <iostream>
using namespace std;

int main()
{
   int m = 0;
   int n = 0;
   [&, n] (int a) mutable { m = ++n + a; }(4);
   cout << m << endl << n << endl;
}

4.Lambda表达式的优缺点

4.1Lambda表达式的优点

可以直接在需要调用函数的位置定义短小精悍的函数，而不需要预先定义好函数

std::find_if(v.begin(), v.end(), [](int& item){return item > 2});

使用Lamdba表达式变得更加紧凑，结构层次更加明显、代码可读性更好

4.2Lambda表达式的缺点

Lamdba表达式语法比较灵活，增加了阅读代码的难度
对于函数复用无能为力

5.Lambda表达式工作原理

5.1Lambda表达式工作原理

编译器会把一个Lambda表达式生成一个匿名类的匿名对象，并在类中重载函数调用运算符，实现了一个operator()方法。

auto print = []{cout << "Hello World!" << endl; };

编译器会把上面这一句翻译为下面的代码：

class print_class
{
public:
	void operator()(void) const
	{
		cout << "Hello World!" << endl;
	}
};
// 用构造的类创建对象，print此时就是一个函数对象
auto print = print_class();

5.2C++仿函数

仿函数（functor）又称为函数对象（function object）是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载operator()运算符，仿函数与Lamdba表达式的作用是一致的。举个例子：

#include <iostream>
#include <string>
using namespace std;
 
class Functor
{
public:
    void operator() (const string& str) const
    {
        cout << str << endl;
    }
};
 
int main()
{
    Functor myFunctor;
    myFunctor("Hello world!");
    return 0;
}

6.Lamdba表达式适用场景

6.1Lamdba表达式应用于STL算法库

（1）`for_each`应用实例

int a[4] = {11, 2, 33, 4};
sort(a, a+4, [=](int x, int y) -> bool { return x%10 < y%10; } );
for_each(a, a+4, [=](int x) { cout << x << " ";} );

输出：

11 2 33 4

（2）`find_if`应用实例

int x = 5;    
int y = 10;    
deque<int> coll = { 1, 3, 19, 5, 13, 7, 11, 2, 17 }; 
auto pos = find_if(coll.cbegin(), coll.cend(), [=](int i) {
    return i > x && i < y; 
    });

（3）`remove_if`应用实例

std::vector<int> vec_data = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int x = 5;
vec_data.erase(std::remove_if(vec.date.begin(), vec_data.end(), [](int i) { 
    return n < x;}), vec_data.end());

std::for_each(vec.date.begin(), vec_data.end(), [](int i) { 
    std::cout << i << std::endl;});

6.2短小不需要复用函数场景

（1）`sort`函数

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(void)
{
    int data[6] = { 3, 4, 12, 2, 1, 6 };
    vector<int> testdata;
    testdata.insert(testdata.begin(), data, data + 6);

    // 对于比较大小的逻辑，使用lamdba不需要在重新定义一个函数
    sort(testdata.begin(), testdata.end(), [](int a, int b){ 
        return a > b; });

    return 0;
}

6.3Lamdba表达式应用于多线程场景

#include <iostream>
#include <thread>
#include <vector>
#include <algorithm>

int main()
{
    // vector 容器存储线程
    std::vector<std::thread> workers;
    for (int i = 0; i < 5; i++)
    {
        workers.push_back(std::thread([]()
            {
                std::cout << "thread function\n";
            }));
    }
    std::cout << "main thread\n";

    // 通过 for_each 循环每一个线程
    // 第三个参数赋值一个task任务
    // 符号'[]'会告诉编译器我们正在用一个匿名函数
    // lambda函数将它的参数作为线程的引用t
    // 然后一个一个的join
    std::for_each(workers.begin(), workers.end(), [](std::thread& t)
        {
            t.join();
        });

    return 0;
}

输出：

main thread
thread function
thread function
thread function
thread function
thread function

std::mutex mutex;
std::condition_variable condition;
std::queue<std::string> queue_data;

std::thread threadBody([&]{
	std::unique_lock<std::mutex> lock_log(mutex);
	condition.wait(lock_log, [&]{
		return !queue_data.front();
	});
	std::cout << "queue data: " << queue_data.front();
	lock_log.unlock();
});

queue_data.push("this is my data");
condition.notity_one();

if(threadBody.joinable())
{
	threadBody.join();
}

6.4Lamdba表达式应用于函数指针与function

#include <iostream>
#include <functional>
using namespace std;

int main(void)
{
    int x = 8, y = 9;
    auto add = [](int a, int b) { return a + b; };
    std::function<int(int, int)> Add = [=](int a, int b) { return a + b; };

    cout << "add: " << add(x, y) << endl;
    cout << "Add: " << Add(x, y) << endl;

    return 0;
}

6.5Lamdba表达式作为函数的入参

using FuncCallback = std::function<void(void)>;

void DataCallback(FuncCallback callback)
{
	std::cout << "Start FuncCallback!" << std::endl;
	callback();
	std::cout << "End FuncCallback!" << std::endl;
}

auto callback_handler = [&](){
	std::cout << "This is callback_handler";
};

DataCallback(callback_handler);

6.6Lamdba表达式在QT中的应用

QTimer *timer=new QTimer;
timer->start(1000);
QObject::connect(timer, &QTimer::timeout, [&](){
        qDebug() << "Lambda表达式";
});

int a = 10;
QString str1 = "汉字博大精深";
connect(pBtn4, &QPushButton::clicked, [=](bool checked){
	qDebug() << a <<str1;
	qDebug() << checked;
	qDebug() << "Hua Windows Lambda Button";
});