lambda表达式简单使用

1.lambda表达式语法

[捕获外部变量]（形参列表）->返回值{操作代码}；

[capture list] (parameter list) -> return type { function body }

如果lambda不需要返回值，那么返回值可以省略。也就是这样：

[捕获外部变量]（形参列表）{操作代码}；

[capture list] (parameter list) { function body }

2.捕获外部变量的方式

• [ ]: 表示不捕获任何外部变量
• [=]: 以传值的方式捕获外部的所有变量
• [&]: 以传引用的方式捕获外部的所有变量
• [this]: 捕获外部的this指针
• [=, &a]: 以传值的方式捕获外部的所有变量，但是a变量以传引用的方式捕获
• [a, b]: 以传值的方式捕获外部变量a和b
• [a, &b]: a以传值方式捕获，b以传引用的方式捕获

3.lambda底层实现原理

第一种，无参无返回值的lambda： 

auto func1 = [](){cout << "hello world!" << endl; };
func1();

其对应的类：

template<typename T=void>
class TestLambda01
{
public:
       TestLambda01() {}
       void operator()()const
       {
          cout << "hello world!" << endl;
       }
};

第二种lambda，参数为整型返回值为整型的：     

auto func2 = [](int a, int b)->int {return a + b; };
cout<<func2(20, 30)<<endl;

其对应的类：

template<typename T = int>
class TestLambda02
{
public:
       TestLambda02() {}
       int operator()(int a, int b)const
       {
          return a+b;
       }
};

第三种是以引用方式获取参数的lambda：

int a = 10;
int b = 20;
auto func3 = [&]() // “a”: 无法在非可变 lambda 中修改通过复制捕获
{
  int tmp = a;
  a = b;
  b = tmp;
};
func3();

其对应的类：

template<typename T = int>
class TestLambda03
{
public:
       TestLambda03(int &a, int &b):ma(a), mb(b) {}
       void operator()()const
       {
          int tmp = ma;
          ma = mb;
          mb = tmp;
       }
private:
       int &ma;
       int &mb;
};

现在我们来总结一下：lambda中的捕获参数列表对应类中成员变量的类型，返回值和参数列表对应operator() 的返回值和参数列表。

4.lambda表达式代替switch

map<int, function<int(int, int)>> caculateMap;
caculateMap[1] = [](int a, int b)->int {return a + b; };
caculateMap[2] = [](int a, int b)->int {return a - b; };
caculateMap[3] = [](int a, int b)->int {return a * b; };
caculateMap[4] = [](int a, int b)->int {return a / b; };

cout << "选择:";
int choice;
cin >> choice;
cout << "10 op  15:" << caculateMap[choice](10, 15) << endl;

5. Lambda表达式的示例

示例一：使用 Lambda表达式定义简单的匿名函数

我们可以使用 Lambda表达式来定义一些简单的匿名函数，例如计算两个数的和、判断一个数是否为奇数等。例如：

#include <iostream>
using namespace std;

int main()
{
    // 定义一个 Lambda表达式，计算两个数的和
    auto plus = [] (int a, int b) -> int { return a + b; };
    // 调用 Lambda表达式
    cout << plus(3, 4) << endl; // 输出 7

    // 定义一个 Lambda表达式，判断一个数是否为奇数
    auto is_odd = [] (int n) { return n % 2 == 1; };
    // 调用 Lambda表达式
    cout << is_odd(5) << endl; // 输出 1
    cout << is_odd(6) << endl; // 输出 0

    return 0;
}

示例二：使用 Lambda表达式捕获外部变量

我们可以使用 Lambda表达式的捕获列表来指定 Lambda表达式可以访问的外部变量，以及是按值还是按引用的方式访问。例如：

#include <iostream>
using namespace std;

int main()
{
    int x = 10;
    int y = 20;

    // 定义一个 Lambda表达式，按值捕获 x 和 y
    auto add = [x, y] () -> int { return x + y; };
    // 调用 Lambda表达式
    cout << add() << endl; // 输出 30

    // 修改 x 和 y 的值
    x = 100;
    y = 200;

    // 再次调用 Lambda表达式
    cout << add() << endl; // 输出 30，捕获的是 x 和 y 的副本，不受外部变化的影响

    // 定义一个 Lambda表达式，按引用捕获 x 和 y
    auto mul = [&x, &y] () -> int { return x * y; };
    // 调用 Lambda表达式
    cout << mul() << endl; // 输出 20000

    // 修改 x 和 y 的值
    x = 1000;
    y = 2000;

    // 再次调用 Lambda表达式
    cout << mul() << endl; // 输出 2000000，捕获的是 x 和 y 的引用，会反映外部变化的影响

    return 0;
}

示例三：使用 Lambda表达式作为函数参数

我们可以使用 Lambda表达式作为函数的参数，这样可以方便地定义和传递一些简单的函数对象，例如自定义排序规则、自定义比较函数等。例如：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 定义一个结构体
struct Item
{
    Item(int aa, int bb) : a(aa), b(bb) {}
    int a;
    int b;
};

int main()
{
    vector<Item> vec;
    vec.push_back(Item(1, 19));
    vec.push_back(Item(10, 3));
    vec.push_back(Item(3, 7));
    vec.push_back(Item(8, 12));
    vec.push_back(Item(2, 1));

    // 使用 Lambda表达式，根据 Item 中的成员 a 升序排序
    sort(vec.begin(), vec.end(), [] (const Item& v1, const Item& v2) { return v1.a < v2.a; });

    // 使用 Lambda表达式，打印 vec 中的 Item 成员
    for_each(vec.begin(), vec.end(), [] (const Item& item) { cout << item.a << " " << item.b << endl; });

    return 0;
}

示例四：使用 Lambda表达式作为函数返回值

我们可以使用 Lambda表达式作为函数的返回值，这样可以方便地定义和返回一些简单的函数对象，例如工厂函数、闭包函数等。例如：

#include <iostream>
using namespace std;

// 定义一个函数，返回一个 Lambda表达式，实现两个数的加法
auto make_adder(int x)
{
    return [x] (int y) -> int { return x + y; };
}

int main()
{
    // 调用函数，得到一个 Lambda表达式
    auto add5 = make_adder(5);
    // 调用 Lambda表达式
    cout << add5(10) << endl; // 输出 15

    return 0;
}

示例出自：深入浅出 C++ Lambda表达式：语法、特点和应用-CSDN博客