lambda.cpp

//
// Created by light on 19-11-3.
//

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

using namespace std;

// [introducer](optional)mutable throwSpec->retType {}
// mutable决定[]能够被改写  mutable throwSpec retType都是选择的,只要有一个存在就得写()
// retType 返回类型
// ()放参数
// []放外面变量 passed by value or reference


class UnNamedLocalFunction {
private:
    int localVar;
public:
    UnNamedLocalFunction(int var) : localVar(var) {}

    bool operator()(int val) {
        return val == localVar;
    }
};

class Person {
public:
    string firstname;
    string lastname;
};

class LambdaFunctor {
public:
    LambdaFunctor(int a, int b) : m_a(a), m_b(b) {}

    bool operator()(int n) const {
        return m_a < n && n < m_b;
    }

private:
    int m_a;
    int m_b;
};

class X {
private:
    int __x, __y;
public:
    X(int x, int y) : __x(x), __y(y) {}

    int operator()(int a) { return a; }

    int f() {
        // 下列 lambda 的语境是成员函数 X::f
        // 对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针
        return [&]() -> int {
            return operator()(this->__x + __y); // X::operator()(this->x + (*this).y)
            // 拥有类型 X*
        }();
    }


    int ff() {
        return [this]() {
            return this->__x;
        }();
    }
};

int main() {

    [] {
        cout << "hello" << endl;
    }();

    auto I = [] {
        cout << "hello" << endl;
    };
    I();
    int id = 0;
    // 先看前面的id 如果没有mutable error: increment of read-only variable ‘id’
    auto f = [id]()mutable {
        cout << "id=" << id << endl;
        ++id;
    };
    id = 42;
    f();    // 0
    f();    // 1
    f();    // 2
    cout << id << endl;

    // 上述lambda就相当于
//    class Functor {
//    private:
//        int id;
//    public:
//        void operator() {
//            cout << "id=" << id << endl;
//            ++id;
//        }
//    };
//    Functor f;

    int id1 = 0;
    // 加不加mutable没影响,且传引用只要后面id1被修改了,就会使用修改后的值进行操作
    auto f1 = [&id1]() {
        cout << "id1=" << id1 << endl;
        ++id1;
    };
    id1 = 42;
    f1();    // 42
    f1();    // 43
    f1();    // 44
    cout << id1 << endl;


    // 传参与返回
    int id2 = 0;
    auto f2 = [&id2](int &param) {
        cout << "id2=" << id2 << endl;
        ++id2;
        ++param;
        cout << "param=" << param << endl;
        static int x = 5;
        return id2;
    };
    int param = 1;
    f2(param);
    cout << "param=" << param << endl;

    // [=] =表示默认以by value传递外部所有变量
    // [&] &表示默认以by reference传递外部所有变量
    auto f3 = [&]() {
        cout << "id=" << id << endl;
        cout << "id1=" << id1 << endl;
        cout << "id2=" << id2 << endl;
        cout << "param=" << param << endl;
    };
    f3();

    // 一部分传引用,其余传值
    cout << "id=" << id << endl;
    auto f4 = [=, &id]() {       // =不可以放在&id后面
        cout << "id=" << id << endl;
        id++;
        cout << "id1=" << id1 << endl;
        cout << "id2=" << id2 << endl;
        cout << "param=" << param << endl;
    };
    f4();

    // 一部分传值,其余传引用
    cout << "id=" << id << endl;
    auto f5 = [&, id]() {       // &不可以放在id后面
        cout << "id=" << id << endl;
        cout << "id1=" << id1 << endl;
        cout << "id2=" << id2 << endl;
        cout << "param=" << param << endl;
    };
    f5();
    // this 指针
    X x_(1, 2);
    cout << "x_.f()=" << x_.f() << endl;   // 1+2=3
    cout << "x_.ff()=" << x_.ff() << endl; // 1



    // 下面lambda函数等价于上述的UnNamedLocalFunction
    int tobefound = 5;
    auto lambda1 = [tobefound](int val) {
        return val == tobefound;
    };
    bool b1 = lambda1(5);
    UnNamedLocalFunction lambda2(tobefound);
    bool b2 = lambda2(5);
    cout << b1 << " " << b2 << endl;

    auto ll1 = [](int x) -> int {
        return x + 10;
    };
    // lambda 匿名函数
    function<int(int x)> ll = [](int x) -> float {
        return x + 10.0;
    };
    cout<<ll(1)<<endl;

    // decltype+lambda
    // 比大小
    function<bool(const Person&p1,const Person&p2)> cmp = [](const Person &p1, const Person &p2) {
        return p1.lastname < p2.lastname;
    };


    // 对于lambda,我们往往只有object,很少有人能够写出它的类型，而有时就需要知道它的类型,要获得其type,就要借助其decltype
    set<Person, decltype(cmp)> col(cmp);

    // 要申明lambda对象的类型，可以使用template或者auto进行自动推导。
    // 如果需要知道类型，可以使用decltype，比如，让lambda函数作为关联容器或者无序容器的排序函数或者哈希函数。
    // 上面代码给出了事例（decltype的第三种用法中的事例），定义了一个lambda函数用cmp表示，用来比较Person对象的大小，传入到Set容器中去，
    // 但根据右边的set容器的定义，我们传入的不仅是cmp（构造函数），还要传入模板的cmp类型（Set内部需要声明cmp类型），
    // 所以必须使用decltype来推导出类型。
    // （如果没有向构造函数传入cmp，调用的是默认的构造函数，也就是set() : t(Compare()), 这里会报错, 现在不会出问题了!
    // 因为Compare()指的是调用默认的lambda构造函数，而lambda函数没有默认构造函数和赋值函数）


    vector<int> vec{5, 28, 50, 83, 70, 590, 245, 59, 24};
    int x = 30, y = 100;
    // 函数对象是很强大的，封装代码和数据来自定义标准库的行为，但需要写出函数对象需要写出整个class，这是不方便的，而且是非本地的，
    // 用起来也麻烦，需要去看怎样使用，另外编译出错的信息也不友好，而且它们不是inline的，效率会低一些（算法效率还是最重要的）。
//    vec.erase(remove_if(vec.begin(), vec.end(), LambdaFunctor(x, y)), vec.end());
//    for(auto i:vec) cout<<i<<" ";
//    cout<<endl;
    // 而lambda函数的提出解决了这个问题，简短有效清晰，上面的事例很好的说明了这个问题，用lambda要简短许多，功能一样，很直观。
    vec.erase(remove_if(vec.begin(), vec.end(), [x, y](int n) { return x < n && n < y; }), vec.end());
    for_each(vec.begin(), vec.end(), [](int i) { cout << i << " "; });
    cout << endl;
    return 0;

}