第17课 lambda表达式

一. lambda表达式

（一）语法定义：[capture](paramters) mutable ->returnType{statement}

　　1.[capture]：捕获列表

　　（1）lambda函数只能捕获父作用域中的局部变量或形参。而捕获非父作用域或静态变量则会出错。（这里的父作用域指的是包含lambda函数的语句块，如main函数作用域）

　　　　①[]：表示不捕获；[=]和[&]：分别表示按值和按引用捕获所有父作域变量（包括this）；

　　　　②[var]、[&var]分别表示按值和按引用捕获var。注意，默认是无法修改按值捕获的变量的值（因为lambda表达式的operator()默认为const）。

　　　　③[=,&foo]：表示按引用捕获foo变量，按值捕获父作用域中所有其它变量。

　　　　④[this]：捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样访问权限。捕获this的目的是可以在lambda中会使用当前类的成员函数和成员变量。

　　（2）注意事项：

　　　　①捕获列表不允许变量重复传递。如[=,a]、[&,&this]其中的a和this都被重复传递。

　　　　②lambda表达式的按值捕获，是在声明lambda表达式的一瞬间就被复制了。如果希望lambda表达式在调用时能即时的访问外部变量，应该使用按引用捕获。

　　　　③默认情况下，按值捕获的变量是不可以被修改的，因为lambda表达式的operator()是个const函数。

　　　　④lambda不能捕获非父作用域变量或static变量。即它们不能被进入捕获列表中，但可在lambda的函数体内直接访问。

  　　2.(parameters)：参数列表。

　　（1）与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号（）一起省略。

　　（2）参数列表不支持默认值，也不支持可变参数。所有的参数必须有参数名。

　　（3）C++14中，参数类型可以声明为auto类型。

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

  　　4.returnType：返回值类型。用追踪返回类型形式声明函数的返回类型。在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行自动推导。如果没有return语句则返回void。

  　　5.{statement}：函数体。内容与普通函数一样，除了可以使用参数之外，还可以使用所有捕获的变量。

（二）lambda表达式与仿函数

 

  　　1. 仿函数是编译器实现lambda表达式的一种方式。在现阶段，通常编译器都会把lambda表达式转化成为一个仿函数对象。因此，在C++11中，lambda可以视为仿函数的一种等价形式或叫“语法糖”。

  　　2. 两者虽然在语法层面上不同，但却有着相同的内涵为——都可以捕捉一些变量作为初始状态并接受参数进行运算。

  　　3. lambda表达式在C++11中被称为“闭包类型（Closure Type）”，可以认为是个仿函数，带有const属性的operator()。它的捕获列表捕获的任何外部变量最终均会变为仿函数的成员变量。由闭包类型定义的对象称为“闭包”（是个右值）。

　　4. 没有捕获变量的lambda表达式可以直接转换为函数指针，而捕获变量的lambda表达式则不能转换为函数指针。

【编程实验】lambda初体验

#include <iostream>

using namespace std;

int gVal = 0;

//捕获this指针
class Test
{
private: 
    int i = 0;
public:
    void func(int x, int y)
    {
        int a = 0;
        //auto lamb1 = [] {return i; }; //error，无捕获列表。
        //auto lamb2 = [&i] {return i; }; //error, 不能捕获父作用域(func域）以外的变量(i)
        auto lamb3 = [=] {return i; }; //ok，按值捕获（含this指针），因此可以访问类中的成员变量(i)。
        auto lamb4 = [&] {return i + x + a; }; //ok，按引用捕获(含this指针），可以使用类中的成员变量(i)
                                               //同时，也捕获到形参x和局部变量a。
        auto lamb5 = [this] {return i; };  //ok，直接捕获this指针。

        auto lamb6 = [] {return gVal++; }; //ok，可以使用直接使用全局变量，无须也不能捕获它。
    }
};

int main()
{
    int a = 3;
    int b = 4;

    //1. lambda表达式初体验
    auto lamb1 = [] {};   //最简单的lambda表达式

    auto lamb2 = [=] {return a + b; };//省略参数列表和返回类型
    cout << lamb2() << endl; //7

    auto lamb3 = [&](int c) {b = a + c; };//省略返回类型，为void。
    //cout << lamb3(5) << endl; //error，返回void

    auto lamb4 = [] {return 1; }; //省略参数列表
    cout << lamb4() << endl;

    auto lamb5 = [=, &b](int c)->int {return b += a + c; }; //各部分完整的lambda表达式
    cout << "lamb5(2) = "<<lamb5(2) << ", b = " << b<< endl; //9, 9

    //2. lambda表达式的常量性及mutable关键字
    a = 1;
    //auto f1 = [] {return a++; };  //error，没有捕获外部变量
    //auto f2 = [=]() { a = 1;};    //error，const函数不能修改按值捕获的变量
    auto f2 = [=]() mutable { a = 2; }; //ok，被mutable修饰
    auto f3 = [&a]() { a = 3; };       //ok，按引用传递。const函数时影响引用本身，表示其不可修改
                                       //但其引用的内容不受const影响，仍可修改。
    //3. 捕获的时间点
    int x = 10;
    auto lambByVal = [x] {return x + 1; }; //按值捕获：声明时，x被复制一下
    auto lambByRef = [&x] {return x + 1; };//按引用捕获：x的值是随外部x的变化而变化。
    cout << "lambByVal() = "<< lambByVal() << endl; //11
    cout << "lambByRef() = "<< lambByRef() << endl; //11
    
    ++x;

    cout << "lambByVal() = " << lambByVal() << endl; //11
    cout << "lambByRef() = " << lambByRef() << endl; //12

    //4. lambda表达式转换为函数指针
    using FuncX = int(*)(int);
    using FuncXY = int(*)(int, int);

    int k = 1;
    auto lambN = [](int x, int y) {return x + y; };       //无捕获列表
    auto lambK = [&k](int x, int y) {return x + y + k; }; //有捕获列表

    FuncXY funcXY;
    funcXY = lambN; //ok，无捕获列表的lambda可转化为函数指针
    //lambN = funcXY; //error，不能将函数指针转为lambda
    //funcXY = lambK; //error，有捕获列表的lambda不能转为函数指针

    //5. 捕获this指针（见Test类）

    return 0;
}

（三）泛型lambda表达式

  　　1. 概述：

 

　　（1）泛型lambda的格式形如 [](auto x, auto y){}; 或 [](auto&& x, auto&& y){} 等。

　　（2）由于auto&&类型的形参没有可用的T类型，泛型lambda采用forward+decltype来转发param。

　　（3）当param被左值实参初始化时，param被推导为左值引用，即decltype(param)为左值引用类型。同理，当param被右值初始化时，即decltype(param)为右值引用类型。

　　（4）decltype(param)作为模板形参传入std::forward时，会发生引用折叠，从而能正确根据实参的左/右值特性进行转发。

　　2. 泛型lambda的优势

　　（1）使用auto作为lambda函数的参数类型修饰符，增加泛型编程能力；

　　（2）泛型lambda允许带auto参数的lambda函数能够转化为函数指针。

【编程实验】泛型lambda

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

int main()
{
    //1. 泛型局部函数
    auto f1 = [](auto x, auto y) {return x + y; };
    cout <<"f1(1, 3) = " << f1(1, 3) << endl;
    cout <<"f1(4.5, 6.3) = " << f1(4.5, 6.3) << endl;
    cout << "f1("abc", "def") = " << f1(string{ "abc" }, "def") << endl;

    //2. 泛型回调函数
    auto f2 = [](auto x) {cout << x << ","; };
    vector<int> v1{1, 2, 3};
    vector<string> v2{ "a","b","c" };
    for_each(v1.begin(), v1.end(), f2); cout << endl;
    for_each(v2.begin(), v2.end(), f2); cout << endl;

    //3. 泛型lambda与函数指针的转换
    auto f3 = [](auto x){ return x; };
    using Func = int(*)(int);
    Func pf = f3;
    cout << pf(5) << endl;  //5

    cout << "----------------------------------"<< endl;
    //4. 利用泛型lambda模拟实现tuple。
    //(1)make_tuple接受可变参数包，返回一个tuple对象（lambda）。
    //   如，auto tp = make_tuple(1, '2', "3");即tp = [](auto access){return access(1, '2', "3")};
    //   可见参数包己被展开，并保存在tp中，可随时供访问器使用。
    //(2)该tuple的使用方式是：tuple(access)，向其传入某种功能的访问器（如打印，求长度函数）
    //   这种通过tuple+access的方式可以达到访问tuple中元素的目的。注意，access为可接受可变参数包的
    //   可调用对象。
    auto make_tuple = [](auto ...xs) {
        return [=](auto access) { return access(xs...); };
    };

    //4.1 求tuple的长度
    auto length = [](auto xs) { //length(tp)，传入tuple
        return xs([](auto ...z) { return sizeof...(z); }); //通过tp(access)向其传入计算元素个数的访问器。
    };

    //4.2 fmap的功能: 将一个tuple(tpSrc)通过func函数映射成另一个新的tuple。如通过对元素*2，
    //将tuple(1,2,3,4)映射成tuple(2,4,6,8)
    auto fmap = [=](auto func) {  //捕获make_tuple
        return [=](auto tpSrc) {  //捕获func和make_tuple
            return tpSrc([=](auto... xs) { return make_tuple(func(xs)...); }); //tuple+访问器方式
        };
    };

    auto tp = make_tuple(1, '2', "3");
    std::cout << length(tp) << std::endl; // 3
    int len = tp([](auto...z) { return sizeof...(z); }); //通过向tuple传入访问器的方式来使用tuple。
                                                      //注意访问器必须可接受可变参数包。
    std::cout << len << std::endl;

    auto twice = [](auto i) { return 2 * i; };  //映射函数
    auto print = [](auto i) { std::cout << i << " "; return i; };
    auto tp1 = make_tuple(1, 2, 3, 4);
    auto tp2 = fmap(twice)(tp1); //将tp1通过twice函数映射成tp2
    auto tp3 = fmap(print)(tp2); //将tp2通过print函数映射成tp3，并通过print将tp2元素打印出来。
                                 //make_tuple(func(xs)...) 等价于make_tuple(func(xs1),func(xs2),...)
                                 //因参数按从右向左依次传入，所以最终打印结果为8,6,4,1

    return 0;
}
/*输出结果
f1(1, 3) = 4
f1(4.5, 6.3) = 10.8
f1("abc", "def") = abcdef
1,2,3,
a,b,c,
5
----------------------------------
3
3
8 6 4 2
*/

二. lambda表达式的优势

（一）使代码更加简化、逻辑更清晰。

（二）使程序更灵活，在需要的时间和地点实现闭包

（三）简化仿函数的使用，使得STL算法的使用更加容易

【编程实验】lambda的优势

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

using namespace std;
using namespace std::placeholders;

int g_ubound = 10;
vector<int> nums = { 8, 9, 10, 11, 12, 13, 14, 15, 16,17,18,19,20 };
vector<int> largeNums;

//显示vector中的元素
void print(vector<int>& vec)
{
    for (auto& elem : vec) {
        cout << elem << " ";
    }

    cout << endl;
}

//函数
inline void LargNumsFunc(int i)
{
    if (i > g_ubound)
    {
        largeNums.push_back(i);
    }
}

//仿函数
class LargeNums
{
private: 
    int ubound;
public:
    LargeNums(int u):ubound(u){}

    void operator()(int i) const
    {
        if (i > ubound)
        {
            largeNums.push_back(i);
        }
    }
};
void test(int ubound)
{
    //1. 使用传统的for(缺点：需要直接使用全局变量g_ubound)
    for (auto iter = nums.begin(); iter != nums.end(); ++iter) {
        if (*iter > ubound) {
            largeNums.push_back(*iter);
        }
    }
    print(largeNums);

    largeNums.clear();
    //2.使用函数指针
    //缺点：函数定义在别的地方，代码阅读不方便。inline非强制性的，内联不一定成功。可
    //      能导致性能问题。且LargeNumFunc由于使用了全局变量，是个有状态函数，函数重用性不高。
    for_each(nums.begin(), nums.end(), LargNumsFunc);
    print(largeNums);

    largeNums.clear();
    //3. 使用仿函数
    //优点：仿函数可以拥有状态，由于for_each第3个参数只能传递一个可调用对象而不能传递额外的参数。
    //      因此，利用仿函数就可以克服这一不足。
    //缺点：需要单独定义一个仿函数类。
    for_each(nums.begin(), nums.end(), LargeNums(g_ubound));
    print(largeNums);

    largeNums.clear();
    //4. 使用lambda表达式
    //优点：比仿函数书写上更简洁，代码的功能更清晰。
    for_each(nums.begin(), nums.end(), [ubound](int i) 
    {
            if (i > ubound) {
                largeNums.push_back(i);
            }
    });
    print(largeNums);
}
int main()
{
    //1. lambda可简化标准库的调用(统计(50,73]之间的元素个数)
    vector<int> v{ 15, 37, 94, 50, 73, 58, 28, 98 };
    //1.1 组合使用bind
    auto f1 = std::bind(std::logical_and<bool>(),
                        std::bind(std::greater<int>(), _1, 50),
                        std::bind(std::less_equal<int>(), _1, 73)
                        );
    cout << count_if(v.begin(), v.end(), f1) << endl; //2

    //1.2 使用lambda表达式
    auto f2 = [](int x) {return (50<x) && (x<=73); };
    cout << count_if(v.begin(), v.end(), f2) << endl; //2
    int cnt = count_if(v.begin(), v.end(), [](int x)
              {
                 return  (50 < x) && (x <= 73);
              });
    cout << cnt << endl; //2

    //2. lambda与其他可调用对象使用上的比较
    test(g_ubound);

    return 0;
}
/*输出结果
2
2
2
11 12 13 14 15 16 17 18 19 20
11 12 13 14 15 16 17 18 19 20
11 12 13 14 15 16 17 18 19 20
11 12 13 14 15 16 17 18 19 20
*/