C++11的一大亮点就是引入了Lambda表达式。Lambda 表达式是一种定义匿名函数对象的简便方法，(关闭)在调用的位置或作为自变量传递给函数的位置。很多高级语言在很早以前就已经提供了Lambda表达式的功能，如C#，Python(argsort函数)等。

Lambda原型

Lambda表达式完整的声明格式如下：

1	[capture list] (params list) mutable exception-> return type { function body }

capture list：捕获外部变量列表
params list：形参列表
mutable：以值捕获方式时是否可以修改捕获的变量(否就省略mutable)
exception：异常设定
return type：返回类型
function body：函数体

常见的省略成分Lambda表达式有以下几种：

[capture list] (params list) -> return type {function body}
[capture list] (params list) {function body}
[capture list] {function body}

格式1声明了const类型的表达式（省略了mutable），这种类型的表达式不能修改捕获列表中的值。
格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型：（1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定；（2）：如果function body中没有return语句，则返回值为void类型。
格式3中省略了参数列表，类似普通函数中的无参函数。

举个栗子

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

bool cmp(int a, int b){
    return  a < b;
}

int main(){
    vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
    vector<int> lbvec(myvec);

    sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
    cout << "predicate function: ";
    for (int it : myvec)  // C++11中基于范围的for循环
        cout << it << ' ';
    cout << endl;

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) { return b < a; });  // Lambda表达式
    cout << "lambda expression: ";
    for (int it : lbvec)
        cout << it << ' ';
}
//输出如下：
predicate function: 2 2 3 3 5 7
lambda expression: 7 5 3 3 2 2

C++11之前，我们使用STL的sort函数，需要提供一个谓词函数。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了。

捕获外部变量

Lambda表达式通过在最前面的方括号[ ]来明确指明其内部可以访问的外部变量，这一过程也称过Lambda表达式“捕获”了外部变量。

值捕获

值捕获和参数传递中的值传递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响影响Lambda表达式中的值。

int main(){
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 234;
    f();  //123
    auto g = [a](int b) { cout << a+b << endl; };
    a = 567;
    g(10);  //244
    auto h = [a] (int b){a=0; cout << a+b << endl; }; //报错，不能修改a
}

注意以传值方式捕获外部变量，则在Lambda表达式函数体中不能修改该外部变量的值。

引用捕获

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符&。

int main(){
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 234;
    f();  //234
    auto g = [&a](int b) { cout << a+b << endl; };
    a = 567;
    g(10);  //577
    auto h = [&a] (int b){a=0; cout << a+b << endl; };
    h(20);  //20
}

隐式捕获

让编译器根据函数体中的代码来推断需要捕获哪些变量，这种方式称之为隐式捕获。隐式捕获有两种方式，分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量，[&]表示以引用捕获的方式捕获外部变量。

int main(){
    int a = 5,b = 8;
    auto f = [=] { cout << a+b << endl; }; 
    f();  // 13
    auto g = [&] { cout << a+b << endl; };
    a = 10;
    b = 15;
    g();  // 25
}

混合方式

C++11中的Lambda表达式捕获外部变量主要有以下形式：

捕获形式	说明
[ ]	不捕获任何外部变量
[变量名, …]	默认以值捕获指定的多个外部变量，如需引用捕获，则要&声明
[=]	以值捕获所有外部变量
[&]	以引用捕获所有外部变量
[=, &x]	变量x以引用捕获，其余变量以传值捕获
[&, x]	变量x以值的捕获，其余变量以引用捕获
[this]	通过引用捕获当前对象
[*this]	通过传值捕获当前对象

LeetCode—506.相对名次

给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都互不相同。

运动员将根据得分决定名次，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：

名次第 1 的运动员获金牌 “Gold Medal” 。
名次第 2 的运动员获银牌 “Silver Medal” 。
名次第 3 的运动员获铜牌 “Bronze Medal” 。
从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 “x”）。
使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。

示例 1：

输入：score = [5,4,3,2,1]
输出：[“Gold Medal”,”Silver Medal”,”Bronze Medal”,”4”,”5”]
解释：名次为 [1st, 2nd, 3rd, 4th, 5th] 。

class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& score) {
        vector<int> order;
        for(int i=0;i<score.size();i++)
            order.push_back(i);
        sort(order.begin(),order.end(),[&score](int a,int b){return score[a]>score[b];});  // 返回的是数组值从大到小的索引值
        vector<string> res(score.size());
        for(int i=0;i<score.size();i++)
        {
            switch(i)
            {
                case 0:res[order[i]]="Gold Medal";break;
                case 1:res[order[i]]="Silver Medal";break;
                case 2:res[order[i]]="Bronze Medal";break;
                default:res[order[i]]=to_string(i+1);break;
            }
        }
        return res;
    }
};

参考 C++ 11 Lambda表达式

506. 相对名次