lambda表达式

#include <iostream>
using namespace std;

class A{
public:
    A(int _a, int _b):a(_a),b(_b){}

    int operator() (){ //重载() 运算符
        cout<<"a = "<<a<<" b = "<<b<<endl;
        return a + b;
    }
private:
    int a;
    int b;
};

int main()
{
    A a(4, 6);
    cout<<a()<<endl; //对象可以像普通函数一样使用
    return 0;
}

int a = 2;
int b = 3;
auto fun = [=]() -> int {
    return a + b;
}

class Fun{
public:
    Fun(int _a, int _b):a(_a),b(_b){}
    int operator() ()const{ //如果上面使用了关键词 mutable，则函数不为const
        return a + b;
    }
private:
    int a;
    int b;
};

#include <iostream>

using namespace std;

int main()
{
    int a = 3,b = 4;
    string c = "lambda";
    float d = 5.754;

    auto fun = [=]{ //以复制的方式捕获当前作用域的所有变量
        //a = 44; //没加 mutable 会报错
        printf("1: a = %d b = %d c = %s d = %.3f\n",a,b,c.c_str(),d);
    };
    fun();

    auto fun1 = [&]{ //以复制的方式捕获当前作用域的所有变量
        a = 30;
        b = 40;
        c = "lambda test";
        d = 1.23455;
        printf("2: a = %d b = %d c = %s d = %.5f\n",a,b,c.c_str(),d);
    };
    fun1();

    auto fun2 = [a, b, &c, &d] () mutable { //a,b以复制的方式捕获c,d以引用的方式捕获
        a = 300;//加了 mutable 说明符 可以修改复制方式捕获的值，但不会影响到原有的值
        b = 400;
        c = "lambda test test";
        d = 11.23455;
        printf("3: a = %d b = %d c = %s d = %.5f\n",a,b,c.c_str(),d);
    };
    fun2();
    printf("4: a = %d b = %d c = %s d = %.5f\n",a,b,c.c_str(),d);//a,b的值没有改变

    return 0;
}

1: a = 3 b = 4 c = lambda d = 5.754
2: a = 30 b = 40 c = lambda test d = 1.23455
3: a = 300 b = 400 c = lambda test test d = 11.23455
4: a = 30 b = 40 c = lambda test test d = 11.23455

#include <iostream>
using namespace std;

void tprintf(int i) //这个函数必须定义  tprintf函数的参数包解析完后,就会调用void tprintf(int i)
{
    cout<<"i = "<<i<<" end"<<endl;
    return;
}

template<typename U, typename ...Ts>
void tprintf(int i, U u, Ts... ts)
{
    auto t = [i, ts...](){ //lambda 捕获参数包
        tprintf(i + 1, ts...);
    };
    std::cout <<"i = "<<i<<" value is " << u << std::endl;
    t();
    return ;
}

int main()
{
    tprintf(1, 1, 'c', 3, 8, "sda", "jjhj");

    int a = 3;
    int b = 4;
    int c = 5;
    auto f = [](){
        cout<<"lambda"<<endl;
    };

    return 0;
}

i = 1 value is 1
i = 2 value is c
i = 3 value is 3
i = 4 value is 8
i = 5 value is sda
i = 6 value is jjhj
i = 7 end

#include <iostream>
using namespace std;

class Lam{
public:
    Lam(int _miA, int _miB):miA(_miA),miB(_miB){}
    ~Lam(){}

    void lamTest();

    void printfAB(int index) const {
        cout<<index<<": miA = "<<miA<<" miB = "<<miB<<endl;
    }

    void setAB(int miA, int miB){
        this->miA = miA;
        this->miB = miB;
    }
private:
    int miA;
    int miB;
};

void Lam::lamTest()
{
    auto f = [*this] {
        this->printfAB(1); //以复制的方式捕获对象时，如果没加 mutable标识符 只能调用 存在const标识符的 函数
        //setAB(5, 6); //编译不过
    };
    f();

    auto f1 = [*this]() mutable{ //加了mutable标识符 编译器生成的 访函数就不为const
        miA = 3;
        miB = 4;
        this->printfAB(2);
        this->setAB(5, 6); //加了mutable标识符 可以调用非const函数
        this->printfAB(3);
    };
    f1();

    this->printfAB(4);//以复制的方式捕获对象 不会对原有对象产生影响

    auto f2 = [this]{//以引用的方式捕获对象
        miA = 7;
        miB = 8;
        this->printfAB(5);
    };
    f2();
}

int main()
{
    Lam lam(1,2);
    lam.lamTest();
    lam.printfAB(6);//f2以引用的方式捕获对象 对原有对象产生了影响
    return 0;
}

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

void lambdaSwitch()  //使用lambda代替switch
{
    map<int,std::function<string()>> lam;
    lam[1] = []{return "lambda1";};
    lam[2] = []{return "lambda2";};
    lam[3] = []{return "lambda3";};

    printf("1: %s\n",lam[1]().c_str());
    printf("2: %s\n",lam[2]().c_str());
    printf("3: %s\n",lam[3]().c_str());
}

class SortTest;
typedef vector<SortTest> SortTestSet;
class SortTest{
public:
    SortTest(int _miId, string _msName):miId(_miId),msName(_msName){}
    ~SortTest(){}

    inline int getId() const{return miId;};
    inline string getName() const{return msName;};
private:
    int miId;
    string msName;
};
void lambdaSort()  //lambda表达式 用于排序
{
    SortTestSet set;
    set.push_back(SortTest(5, "sort"));
    set.push_back(SortTest(15, "sortsortsort"));
    set.push_back(SortTest(7, "sortsortsortsortsort"));
    set.push_back(SortTest(2, "sortsortsortsort"));
    set.push_back(SortTest(4, "sortsort"));

    sort(set.begin(), set.end(), [](SortTest a, SortTest b){
        //return a.getId() < b.getId();//按照 miId的大小排序
        return a.getName() < b.getName();//按照 msName的长度排序
    });

    for(auto s:set){
        cout<<"sort: id = "<<s.getId()<<" name = "<<s.getName()<<endl;
    }
}

int main()
{
    lambdaSwitch();
    lambdaSort();
    return 0;
}