lambda函数用法总结

概念

lambda函数是C++ 11引入的新特性，在其它语言中也有lambda，典型的如javascript。它是函数编程的基础。在C++中，lambda表示匿名函数，特点是就地定义就地使用，它是一种语法糖，编译器会将它翻译成函数对象。所以它并不是一个"黑科技"。C ++ 11引入lambda表达式的目的就是要就地书写，就地使用，提供一种简化代码的手段。所以咱们主要是了解它的使用。

基础用法

1. 语法

捕捉列表+参数列+函数体

1.[ 捕获 ] ( 形参 ) -> ret { 函数体 }
2.[ 捕获 ] ( 形参 ) { 函数体 }	
3.[ 捕获 ] { 函数体 } 

#include <iostream>
int main()
{
    auto f = [](int i){std::cout<<i<<std::endl;};
    f(18);
    std::getchar();
}

语法1是lambda函数的完整形式，其中ret为返回值类型

语法2是省略返回值类型的，返回值类型可以通过函数体中的return语句推导

语法3表示不接受函数实参

• 在stl中算法中传入一个lambda表达式

这是lambda最常用的方式，简化代码

#include<iostream>
#include <vector>
#include <algorithm>
int main()
{
    std::vector<int> v = { 1,5,3,1,2,9 };
    std::stable_sort(v.begin(), v.end(),
                    [](const int&a, const int&b){
                        return a < b;});

    std::for_each(v.begin(),v.end(),
                    [](const int&a){
                        std::cout << a <<" ";});

    std::system("pause");
}

上面的代码使用std::stable_sort进行从小到大的排序，它最后一个参数是需要一个判断式(可以是一个可调用对象)，在这里直接传入了一个lambda匿名函数。在for_each中传入一个lambda表达式，打印v中的值。

在任何需要可调用对象的接口，我们都可以传入一个lambda匿名函数

2. 使用捕获列表

• 捕获列表是一个lambda所在父作用域定义的变量的列表
• 空捕获列表表示不使用它所在父作用域的任何局部变量

父作用域指的是包含lambda函数的语句块

//一个lambda表达式可以出现在一个函数中，可以通过捕获列表获取用该函数的局部变量
#include <iostream>
void func(int a)
{
    auto f = [a](int i){std::cout<<a+i<<std::endl;};
    f(18)
}

int main()
{
    func(18);
}

#include <iostream>

void func()
{
    int a = 1;
    int b = 2;
    auto f = [a]() {std::cout << a << std::endl; };
    f();
}

int main()
{
    func();
    std::system("pause");
}

• 捕获列表跟函数的形参一样，有值类型，也有引用类型

[var] 表示值传递的方式，前面都是值传递的例子，[&var] 表示引用传递捕捉变量var

#include <iostream>
void func()
{
    int a = 1;
    auto f = [&a]() {std::cout << a << std::endl; };
    a = 2;
    f();
}

int main()
{
    func();
    std::system("pause");;
}

上面的代码中，通过引用捕获了func函数中的局部变量a，当a的值改变时，调用f后，输出的改变后的值。

4. 隐式捕获

上面介绍的都是显示捕获的例子即在捕获列表中指定需要捕获的局部变量，我们也可以使用隐式捕获即不在捕获列表中指定局部变量，而是要编译器进行推导，在捕获列表中写一个&或=

• [=] 表示值传递方式捕捉所有父作用域的变量
• [&] 表示引用传递捕捉所有父作用域的变量

#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
    int v1 = 2;
    int v2 = 9;
    std::vector<int> v = { 2,1,2,8,7,9 };
    for_each(v.begin(), v.end(), [=](const int &i)
    {if (i > v1 && i < v2)
     {
        std::cout << i << " ";
     }
    
    });

    std::getchar();
}

上面的代码在捕获列表写入=，表示隐式捕获，lambda函数中的v1，v2直接由编译推导。

• 捕获对象的this指针

#include <iostream>
#include <vector>
class CTest
{
public:
    CTest()
    {
        vecValue.push_back(18);
        vecValue.push_back(118);
    }

    ~CTest() {};

public:
    void Test()
    {
        //也可以使用[this]或[&]捕获列表
        auto f = [=]() {
            //访问_vecValue等价于通过this->vecValue访问
            for (int i = 0; i < vecValue.size(); ++i)
            {
                std::cout << vecValue[i] << std::endl;
            }
        };

        f();
    }

private:
    std::vector<int> _vecValue;
};

int main()
{
    CTest c;
    c.Test();
    std::getchar();
}

[this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员相同的访问权限,捕获this的目的是可以在lambda中使用当前类的成员函数，成员变量。这里要注意的是如果通过[=]或[&]捕获，实际捕获的是this指针并不是捕获的成员变量vecValue。改为如下语句，会编译报错。

void Test()
{
    //编译不过
    auto f = [vecValue](){
        for (int i = 0; i < vecValue.size(); ++i)
            {
                std::cout << vecValue[i] << std::endl;
            }
    };
    
    f();
}

类的成员函数中使用lambda，通过[=]/[&]/[this]捕获，实际是捕获的this指针。如果在类的对象被销毁后，再调用lambda表达式就会出现问题。

5 .可变lambda

默认情况下，对于值捕获的变量，在lambda函数中是不能改变其值的。必须加上mutable修饰符才可以改变。

#include <iostream>

int main()
{
    int v = 0;
    auto f = [v]()mutable {++v; };
    f();
    std::cout << v << std::endl;
    std::system("pause");
}

但是针对引用捕获是否可以修改，则不需要加上mutable修饰符，而是根据引用是否是const来确定。

#include <iostream>

int main()
{
    //const int v = 1;
    int v = 1;
    auto f = [&v] {++v; };
    f();
    std::cout << v << std::endl;
    std::system("pause");
}

• 值捕获与引用捕获的区别

#include<iostream>
int main()
{
    int j=12;
    auto by_val_lambda=[=]{return j+1;};
    auto by_ref_lambda=[&]{return j+1;};
    cout<<"by_val_lambda:"<<by_val_lambda() <<endl;
    cout<<"by_val_lambda:"<<by_val_lambda() <<endl;
    j++;
    cout<<"by_val_lambda:"<<by_val_lambda() <<endl;
    cout<<"by_val_lambda:"<<by_val_lambda() <<endl;
}

在使用lambda时，如果需要捕捉的值成为lambda函数的常量，我们通常会使用按值传递的方式捕捉((默认情况下 lambda函数是一个const函数，对于按值方式的捕获列表，在lambda定义时就已经确定了)。
如果需要捕捉的值成为lambda函数运行的变量(类似于参数的效果)，则应该采用按引用方式进行捕捉。

#include <iostream>
int main()
{
    int j = 12;
    auto by_val_lambda = [=] {return j + 1; };
    auto by_ref_labmbda = [&] {return j + 1; };
    std::cout << "by_val_lambda:" << by_val_lambda() << std::endl;
    std::cout << "by_ref_lambda:" << by_ref_labmbda() << std::endl;
    j++;
    std::cout << "by_val_lambda:" << by_val_lambda() << std::endl;
    std::cout << "by_ref_lambda:" << by_ref_labmbda() << std::endl;
    getchar();
}

在by_val_lambda中，j被视为了一个常量，一旦初始化后不会再改变(可以认为之后只是一个跟父作用域中j同名的常量)，而在by_ref_lambda中，j仍在使用父作用域中的值。

lambda可以通过捕获列表捕获到局部作用域中所有类型的变量，可以是值类型或引用类型。所以在lambad表达式被执行时必须确保它所捕获的引用或指针是有效的

STL与lambda

在STL的算法中需要传入可调用对象，通过lambda可以大大简化编码，下面的例子示范了在STL中传入函数，函数对象，lambda的用法及区别

#include <iostream>
#include <vector>
#include <algorithm>
void PrintValue(int i)
{
    if (i > 60)
    {
        std::cout << i << " ";
    }
}

class CPrintValue
{
public:
    CPrintValue(int iValue) :m_iValue(iValue)
    {

    }

    void operator()(int i)
    {
        if (i > m_iValue)
        {
            std::cout << i << " ";
        }
    }

private:
    int m_iValue;
};

void Check(int iCheck)
{
    std::vector<int> vecAllInfo = { 70,50,99,89,90,45,59 };
    //传入一个普通函数
    std::for_each(vecAllInfo.begin(), vecAllInfo.end(), PrintValue);
    std::cout << std::endl;
    //传入一个函数对象
    std::for_each(vecAllInfo.begin(), vecAllInfo.end(), CPrintValue(iCheck));
    std::cout << std::endl;
    //通过lambda实现
    std::for_each(vecAllInfo.begin(), vecAllInfo.end(), [=](int i) {
        if (i > iCheck)
        {
            std::cout << i << " ";
        }; });

}

int main()
{
    Check(60);
    std::getchar();
}

上面的代码实现从一个集合中过滤出大于60的值，通过STL中的for_each实现循环，分别使用了函数指针，函数对象和lambda来处理具体的过滤。

• 函数对象

相较普通函数最大的优势就是可以记录状态，上面的代码中函数对象CPrintValue有一个私有成员变量用以记录要过滤的阈值

• 普通函数

无法记录状态，如上代码，在PrintValue函数是写死了60作为过滤值，当然可以在添加一个形参，但是在使用fore_each的场景显然不适用，因为fore_each第三个参数要求传入的是一个一元函数。

• lambda表达

lambda本质上就是函数对象，它也可以记录状态，作用与函数对象相同。

但是在这个例子中，我们可以很直观的看到lambda的实现相较函数对象的实现要简洁。

• 下面我们再看个例子：

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

std::vector<int> vecValue = { 1,2,3,4,5,6 };

void Print()
{
    for_each(vecValue.begin(), vecValue.end(), [](int i) {
        std::cout << i << " ";});
}

void AddValue(int Value)
{
    //通过std中内置的函数对象bind2nd和plus实现
    std::for_each(vecValue.begin(), vecValue.end(), std::bind2nd(std::plus<int>(), Value));
    Print();
    std::cout << std::endl;
    //使用transform改变vecValue中的值
    std::transform(vecValue.begin(), vecValue.end(), vecValue.begin(), std::bind2nd(std::plus<int>(), Value));
    Print();
    std::cout << std::endl;
    //使用for_each和lambda改变vecValue中的值
    std::for_each(vecValue.begin(), vecValue.end(), [=](int &i) {i += Value; });
    Print();

}

int main()
{
    AddValue(10);
    std::getchar();
}

上面的例子是将vecValue中的值加一个值，通过函数对象/lambda与STL结合实现：

• 首先用for_each+ 函数对象的方式，但是有个问题，for_each并不会改变vecValue中的值。所以这里需要通过变动性算法，
  transform，它的第三个参数为一元表达式，通过bind2nd与plus相结合实现对vecValue中的值改动。

• 通过for_each + lambda的方式，for_each和一个型参为引用类型的lambda表达式实现transform的功能，可以直接通过for_each来改变vecValue的值

lambda显然比直接使用transform算法简单，也不用关心for_each与transform的区别。使用lambda更加简洁明了。