第13课lambda表达式

#include <iostream>

using namespace std;

int g = 0;

class Test
{
private:
    int i = 0;
public:
    
    void func(int x, int y)
    {
        //auto x1 = []{return i;};   //error，没有捕获任何变量。当然也无法捕获父作用域(func)以外的变量，因此i是不能访问到的！
        //auto x1 = [&i]{return i;}; //error，无法捕获父作用域(func)以外的变量
        auto x1 = [=]{return i++;}; //ok，因为“=”或“&”默认会捕获this指针，也就可以访问到成员变量。根据按值捕获的特点，此时
                                    //在lambda的函数体内不能修改this指针本身。但这不影响我们通过this指针修改成员变量i的值！
        
        auto x2 = []{return g++;};  //ok，g不在lambda的父作用域，不能被捕获。
                                    //如auto x2 = [&g]{return g++;}。但由于g是全局变量
                                    //所以在lambda的body内仍是可见的！
                                    
        auto x3 = [=]{return i++, i + x + y;};//ok,按值捕获所有外部变量,由于&或=捕获时会默认地同时传入this，所以可改变i的值
        auto x4 = [&]{return i + x + y;}; //ok,按引用捕获所有变量:x, y以及this指针
                                          //但注意，i没有被捕获，也不可捕获到。它是通过this指针来访问到的。
                                          
        auto x5 = [this]{return i++;};    //ok,捕获了this指针，也就可以修改成员的值
        //auto x6 = [this, x]{return i + x + y;}; //error，没捕获y
    }
};

int main()
{
    []{}; //最简单的lambda表达式
    
    //使用返回值后置语法
    auto f1 = [](int a) ->int {return a + 1;}; 
    cout << f1(1) << endl; //输出2
    
    //省略了返回值类型，由return语法推断
    auto f2 = [](int i){return i + 1;};  //注意：初始化列表不能用于返回值的自动
                                         //推导：如auto x = [](){return {1, 2};};
    cout << f2(1) << endl; //输出2
    
    //参数列表为空时可以省略
    auto f3 = []{return 1;}; //等价于 auto f3 = [](){return 1;};
    cout << f3 << endl;      //等价于 cout << f3() << endl;
    
    int a = 0, b = 1;
    //auto f4 = []{return a;}; //error，没有捕获外部变量
    auto f5 = [&]{return a++;}; //ok，a=1;
    //auto f6 = [=]{return a++;}; //error,按值捕获的
    auto f7 =[a, &b]{return a + (b++);};//ok,按值捕获a，按引用捕获b++
    
    return 0;
}

#include <iostream>

using namespace std;

int main()
{
    //1. 按值和按引用捕获的比较
    int a = 12;
    auto f_val = [=] {return a + 1;}; //按值捕获：表达式中a的值是外部变量a的副本，
                                      //在捕获一瞬间己确定下来。
    auto f_ref = [&] {return a + 1;}; //按引用捕获
    
    cout << "f_val: " << f_val() << endl; //13
    cout << "f_ref: " << f_ref() << endl; //13
    
    a++;  //修改a值,a==13
    
    cout << "f_val: " << f_val() << endl;//13，注意这里输出没变！
    cout << "f_ref: " << f_ref() << endl;//14
    
    //2. 修改按值捕获的变量（只能影响lambda表达式，不影响外部变量）
    //auto f1 = [=]{erturn a++;}; //error，operator()是const函数！
    auto f1 = [=]()mutable{cout << "++a: " << ++a << endl; return a;}; //必须写参数列表，即使为空!
    cout << f1() << endl; //14
    cout << a << endl;    //13
    
    //3. lambda与函数指针的转换
    using func_t = int (*)(int, int);
    func_t f2 = [](int a, int b){return a + b;}; //ok,捕获列表必须为空！
    cout << f2(10, 20) << endl; //30
    
    //4. mutable关键字
    int val = 0;
    //auto f3 = [=](){val = 3;}; //编译失败：const函数，不能修改按值捕获的变量
    auto f3 = [=]()mutable{ val = 3;};//ok,加了mutable关键字
    
    auto f4 =[&](){val = 3;};  //ok，依然是const函数，但可以修改按引用捕获的变
                               //量（不过没改动引用本身）
    auto f5 = [=](int v) { v = 3;}; //传参方式将val传
    f5(val); //传参方式将val传入，与普通函数的传参方式等效！
        
    return 0;
}

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

using namespace std;
using namespace std::placeholders;


const 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 show(vector<int>& vec)
{
    for(auto& elem : vec){
        cout << elem << " ";
    }
    
    cout << endl;
}

//函数指针
inline void LargeNumsFunc(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);
        }
    }
};

//找出vector中大于ubound的元素
void test(int ubound)
{
    //1. 使用传统的for
    //缺点： 需要直接使用全局变量ubound
    for(auto iter = nums.begin(); iter != nums.end(); ++iter){
        if(*iter > ubound)
            largeNums.push_back(*iter);
    }
    show(largeNums);
    largeNums.clear();
    
    //2. 使用函数指针:
    //缺点：函数定义在别的地方，代码阅读不方便
    //      inline并非强制，可能导致效率问题，特别是循环次数较多的时候
    //      LargeNumsFunc是个有状态的函数，直接使用了全局变量(g_ubound)，
    //      函数的可重用性不高！
    for_each(nums.begin(), nums.end(), LargeNumsFunc);
    show(largeNums);
    largeNums.clear();    
    
    //3. 使用仿函数
    //优点： 仿函数可以拥有状态，由于for_each第3个参数的只能传递一个可调用对象，而不能
    //       传递额外的参数很有利，因为可以将ubound作为仿函数的参数传入。
    //缺点： 需要单独定义一个仿函数类 
    for_each(nums.begin(), nums.end(), LargeNums(ubound));
    show(largeNums);
    largeNums.clear();
    
    //4. 使用lambda表达式
    //优点： 比仿函数书写上更简便，函数的功能（找出大于ubound的元素）更清晰
    for_each(nums.begin(), nums.end(), [=](int i){ //“=”会捕获test(int ubound)中的ubound变量
                  if(i>ubound)
                  largeNums.push_back(i);      
            });
    show(largeNums);
    largeNums.clear();    
}

int main()
{
    //1. 简化标准库的调用（统计(50,73]之间元素的个数）
    vector<int> v{15, 37, 94, 50, 73, 58, 28, 98};
    
    //组合使用bind
    auto f1 = bind(logical_and<bool>(), bind(greater<int>(), _1, 50), 
                                        bind(less_equal<int>(), _1, 73));
    cout << count_if(v.begin(), v.end(), f1) << endl; //2
    
    //使用lambda表达式
    auto f2 = [](int x)->bool {return (50<x)&&(x<=73);};
    cout << count_if(v.begin(), v.end(), f2) << endl; //2
    //cout << count_if(v.begin(), v.end(), [](int x)->bool {return (50<x)&&(x<=73);}) << endl;
    
    //2. lambda表达式与其他callable object的对比
    test(g_ubound);
    
    return 0;
}
/*输出结果
e:\Study\C++11\13>g++ -std=c++11 test3.cpp
e:\Study\C++11\13>a.exe
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
*/