int main()
{
    //一個簡單的lambda表達(dá)式
    auto add1 = [](int x, int y)->int
        {
            return x + y;
        };
    cout << add1(1, 2) << endl; //3
    //1.捕捉為空也不能省略
    //2.參數(shù)為空可以省略
    //3.返回值可以省略，可以通過返回對象自動推導(dǎo)
    //4.函數(shù)體不能省略
    auto func1 = []  //省略參數(shù)、返回類型
        {
            cout << "hello ssp" << endl;
            return 0;
        };
    func1();    //hello ssp
    int a = 0, b = 1;
    auto swap1 = [](int& x, int& y)  //省略返回類型
        {
            int tmp = x;
            x = y;
            y = tmp;
        };
    swap1(a, b);
    cout << a << ":" << b << endl;  //1:0
    return 0;
}

int x = 0;
//定義在全局捕捉列表必須為空，因為全局變量不用捕捉就可以用，沒有可捕捉的變量
auto func1 = []()
    {
        x++;
    };
int main()
{
    //只能用當(dāng)前l(fā)ambda局部域和捕捉的對象和全局對象
    int a = 0, b = 1, c = 2, d = 3;
    auto func1 = [a, &b]    //除了類域，都是向上查找
        {
            //值捕捉的變量不能修改，引用捕捉的變量可以修改
            //a++ //錯誤
            b++; //會影響外面的b
            int ret = a + b;
            return ret;
        };
    cout << func1() << endl;    //2
    //隱式值捕捉
    //用了哪些變量就捕捉哪些變量
    auto func2 = [=]()
        {
            int ret = a + b + c;
            return ret;
        };
    cout << func2() << endl;    //4
    //隱式引用捕捉
    //用了哪些變量就捕捉哪些變量
    auto func3 = [&]
        {
            a++;
            c++;
            d++;
        };
    func3();
    cout << a << " " << b << " " << c << " " << d << endl;
    //1 2 3 4
    //混合捕捉1
    auto func4 = [&, a, b]
        {
            //a++;
            //b++;
            c++;
            d++;
            return a + b + c + d;
        };
    func4();
    cout << a << " " << b << " " << c << " " << d << endl;
    //1 2 4 5
    //混合捕捉2
    auto func5 = [=, &a, &b]
        {
            a++;
            b++;
            //c++;
            //d++;
            return a + b + c + d;
        };
    func5();
    cout << a << " " << b << " " << c << " " << d << endl;
    //2 3 4 5
    //局部的靜態(tài)和全局變量不能捕捉，也不需要捕捉
    static int m = 0;
    auto func6 = []
        {
            int ret = x + m;
            return ret;
        };
    //傳值捕捉本質(zhì)是一種拷貝，并且被const修飾了
    //mutable相當(dāng)于去掉const屬性，可以修改了
    //但是修改不會影響外面被捕捉的值，因為是一種拷貝
    auto func7 = [=]()mutable
        {
            a++;
            b++;
            c++;
            d++;
            return a + b + c + d;
        };
    cout << func7() << endl;    //18
    cout << a << " " << b << " " << c << " " << d << endl;
    //3 4 5 6
    return 0;
}

struct Goods
{
    string _name;   //名字
    double _price;  //價格
    int _evaluate;  //評價
    Goods(const char* str, double price, int evaluate)
        :_name(str)
        , _price(price)
        , _evaluate(evaluate)
    {}
};
struct ComparePriceLess
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price < gr._price;
    }
};
struct ComparePriceGreater
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price > gr._price;
    }
};
int main()
{
    vector<Goods> v = { { "蘋果", 2.1, 5 }, { "?蕉", 3, 4 }, 
    { "橙?", 2.2, 3 }, { "菠蘿", 1.5, 4 } };
    //類似這樣的場景，我們實現(xiàn)仿函數(shù)對象或者函數(shù)指針支持不同項的比較
    //相對還是比較麻煩的，不寫注釋也方便理解，那么用lambda就很好用了
    sort(v.begin(), v.end(), ComparePriceLess());
    sort(v.begin(), v.end(), ComparePriceGreater());
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._price < g2._price; 
        });
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._price > g2._price;
        });
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._evaluate < g2._evaluate;
        });
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._evaluate > g2._evaluate;
        });
    return 0;
}

#include <functional>
int f(int a, int b)
{
    return a + b;
}
struct Functor
{
public:
    int operator()(int a, int b)
    {
        return a + b;
    }
};
class Plus
{
public: 
    Plus(int n=10)
        :_n(n)
    { }
    static int plusi(int a, int b)
    {
        return a + b;
    }
    double plusd(double a, double b)
    {
        return (a + b) * _n;
    }
private:
    int _n;
};
int main()
{
    //包裝各種可調(diào)用對象,需要參數(shù)類型匹配
    function<int(int, int)> f1 = f; //第一個int是返回值類型，(int.int)為參數(shù)列表
    function<int(int, int)> f2 = Functor();
    function<int(int, int)> f3 = [](int a, int b) {return a + b; };
    cout << f1(1, 1) << endl;
    cout << f2(1, 1) << endl;
    cout << f3(1, 1) << endl;
    //包裝靜態(tài)成員函數(shù)
    //成員函數(shù)要指定類域并且前面加&才能獲取地址
    //&靜態(tài)的可加可不加，非靜態(tài)的必須加&
    function<int(int, int)> f4 = &Plus::plusi;
    cout << f4(1, 1) << endl;
    //包裝普通成員函數(shù)
    //普通成員函數(shù)還有一個隱含的this指針參數(shù)，
    //所以綁定時要傳對象或者對象的引用或指針過去
    function<double(Plus*, double, double)> f5 = &Plus::plusd;
    Plus pd;    //是用傳入的對象去調(diào)用函數(shù)
    cout << f5(&pd, 1.1, 1.1) << endl;
    function<double(Plus, double, double)> f6 = &Plus::plusd;
    cout << f6(pd, 1.1, 1.1) << endl;
    function<double(Plus&&, double, double)> f7 = &Plus::plusd;
    cout << f7(move(pd), 1.1, 1.1) << endl; //用右值引用
    cout << f7(Plus(), 1.1, 1.1) << endl;   //用匿名對象
    return 0;
}

class Plus
{
public: 
    Plus(int n=10)
        :_n(n)
    { }
    static int plusi(int a, int b)
    {
        return a + b;
    }
    double plusd(double a, double b)
    {
        return (a + b) * _n;
    }
private:
    int _n;
};
int main()
{
    auto sub1 = bind(Sub, _1, _2);
    cout << sub1(10, 5) << endl;    //50
    //bind本質(zhì)是返回的一個仿函數(shù)對象
    //調(diào)整參數(shù)順序（不常用）
    //_1表示第一個實參
    //_2表示第二個實參
    //……
    auto sub2 = bind(Sub, _2, _1);
    cout << sub2(10, 5) << endl;    //-50
    //調(diào)整參數(shù)個數(shù)(常用)
    auto sub3 = bind(Sub, 100, _1); //把a固定為100
    cout << sub3(3) << endl;    //970
    auto sub4 = bind(Sub, _1, 100); //把b固定為100
    cout << sub4(3) << endl;    //-970
    //分別綁死第123個參數(shù)
    auto sub5 = bind(SubX, 100, _1, _2);    //100-_1-_2
    cout << sub5(5, 1) << endl;
    auto sub6 = bind(SubX, _1, 100, _2);    //_1-100-_2
    cout << sub6(5, 1) << endl;
    auto sub7 = bind(SubX, _1, _2, 100);    //_1-_2-100
    cout << sub7(5, 1) << endl;
    //成員函數(shù)對象進(jìn)行綁死，就不需要每次傳遞了
    function<double(Plus&&, double, double)> f6 = &Plus::plusd;
    Plus pd;
    cout << f6(move(pd), 1.1, 1.1) << endl;
    cout << f6(Plus(), 1.1, 1.1) << endl;
    //bind一般用于綁死一些固定參數(shù)
    function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
    cout << f7(1.1, 1.1) << endl;
    return 0;
}