Lambda表達式詳解————————C++

C++ 11 Lambda表達式
C++11的一大亮點就是引入了Lambda表達式。利用Lambda表達式，可以方便的定義和創建匿名函數。對於C++這門語言來說來說，“Lambda表達式”或“匿名函數”這些概念聽起來好像很深奧，但很多高級語言在很早以前就已經提供了Lambda表達式的功能，如C#，Python等。今天，我們就來簡單介紹一下C++中Lambda表達式的簡單使用。


聲明Lambda表達式
Lambda表達式完整的聲明格式如下：


[capture list] (params list) mutable exception-> return type { function body }
各項具體含義如下


capture list：捕獲外部變量列表
params list：形參列表
mutable指示符：用來說用是否可以修改捕獲的變量
exception：異常設定
return type：返回類型
function body：函數體
此外，我們還可以省略其中的某些成分來聲明“不完整”的Lambda表達式，常見的有以下幾種：


序號 格式
1 [capture list] (params list) -> return type {function body}
2 [capture list] (params list) {function body}
3 [capture list] {function body}
其中：


格式1聲明瞭const類型的表達式，這種類型的表達式不能修改捕獲列表中的值。
格式2省略了返回值類型，但編譯器可以根據以下規則推斷出Lambda表達式的返回類型：
 （1）：如果function body中存在return語句，
 則該Lambda表達式的返回類型由return語句的返回類型確定；
 （2）：如果function body中沒有return語句，則返回值爲void類型。
格式3中省略了參數列表，類似普通函數中的無參函數。


講了這麼多，我們還沒有看到Lambda表達式的廬山真面目，下面我們就舉一個實例。


複製代碼
#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:" << endl;
    for (int it : myvec)
        cout << it << ' ';
    cout << endl;


    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表達式
    cout << "lambda expression:" << endl;
    for (int it : lbvec)
        cout << it << ' ';
}
複製代碼
在C++11之前，我們使用STL的sort函數，需要提供一個謂詞函數。如果使用C++11的Lambda表達式，
我們只需要傳入一個匿名函數即可，方便簡潔，而且代碼的可讀性也比舊式的做法好多了。


下面，我們就重點介紹一下Lambda表達式各項的具體用法。


捕獲外部變量
Lambda表達式可以使用其可見範圍內的外部變量，但必須明確聲明
（明確聲明哪些外部變量可以被該Lambda表達式使用）。
那麼，在哪裏指定這些外部變量呢？
Lambda表達式通過在最前面的方括號[]來明確指明其內部可以訪問的外部變量，
這一過程也稱過Lambda表達式“捕獲”了外部變量。


我們通過一個例子來直觀地說明一下：


複製代碼
#include <iostream>
using namespace std;


int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    f(); // 輸出：123


    //或通過“函數體”後面的‘()’傳入參數
    auto x = [](int a){cout << a << endl;}(123); 
}
複製代碼
上面這個例子先聲明瞭一個整型變量a，然後再創建Lambda表達式，
該表達式“捕獲”了a變量，這樣在Lambda表達式函數體中就可以獲得該變量的值。


類似參數傳遞方式（值傳遞、引入傳遞、指針傳遞），在Lambda表達式中，
外部變量的捕獲方式也有值捕獲、引用捕獲、隱式捕獲。


1、值捕獲


值捕獲和參數傳遞中的值傳遞類似，被捕獲的變量的值在Lambda表達式創建時通過值拷貝的方式傳入，因此隨後對該變量的修改不會影響影響Lambda表達式中的值。


示例如下：


複製代碼
int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 321;
    f(); // 輸出：123
}
複製代碼
這裏需要注意的是，如果以傳值方式捕獲外部變量，
則在Lambda表達式函數體中不能修改該外部變量的值。


2、引用捕獲


使用引用捕獲一個外部變量，只需要在捕獲列表變量前面加上一個引用說明符&。如下：


複製代碼
int main()
{
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 321;
    f(); // 輸出：321
}
複製代碼
從示例中可以看出，引用捕獲的變量使用的實際上就是該引用所綁定的對象。


3、隱式捕獲


上面的值捕獲和引用捕獲都需要我們在捕獲列表中顯示列出Lambda表達式中使用的外部變量。
除此之外，我們還可以讓編譯器根據函數體中的代碼來推斷需要捕獲哪些變量，
這種方式稱之爲隱式捕獲。隱式捕獲有兩種方式，分別是[=]和[&]。
[=]表示以值捕獲的方式捕獲外部變量，[&]表示以引用捕獲的方式捕獲外部變量。


隱式值捕獲示例：


int main()
{
    int a = 123;
    auto f = [=] { cout << a << endl; };    // 值捕獲
    f(); // 輸出：123
}
隱式引用捕獲示例：


複製代碼
int main()
{
    int a = 123;
    auto f = [&] { cout << a << endl; };    // 引用捕獲
    a = 321;
    f(); // 輸出：321
}
複製代碼
4、混合方式


上面的例子，要麼是值捕獲，要麼是引用捕獲，Lambda表達式還支持混合的方式捕獲外部變量，
這種方式主要是以上幾種捕獲方式的組合使用。


到這裏，我們來總結一下：C++11中的Lambda表達式捕獲外部變量主要有以下形式：


捕獲形式 說明
[] 不捕獲任何外部變量
[變量名, …] 默認以值得形式捕獲指定的多個外部變量（用逗號分隔），如果引用捕獲，
需要顯示聲明（使用&說明符）
[this] 以值的形式捕獲this指針
[=] 以值的形式捕獲所有外部變量
[&] 以引用形式捕獲所有外部變量
[=, &x] 變量x以引用形式捕獲，其餘變量以傳值形式捕獲
[&, x] 變量x以值的形式捕獲，其餘變量以引用形式捕獲
修改捕獲變量
前面我們提到過，在Lambda表達式中，如果以傳值方式捕獲外部變量，
則函數體中不能修改該外部變量，否則會引發編譯錯誤。
那麼有沒有辦法可以修改值捕獲的外部變量呢？這是就需要使用mutable關鍵字，
該關鍵字用以說明表達式體內的代碼可以修改值捕獲的變量，示例：


複製代碼
int main()
{
    int a = 123;
    auto f = [a]()mutable { cout << ++a; }; // 不會報錯
    cout << a << endl; // 輸出：123
    f(); // 輸出：124
}
複製代碼
Lambda表達式的參數
Lambda表達式的參數和普通函數的參數類似，那麼這裏爲什麼還要拿出來說一下呢？
原因是在Lambda表達式中傳遞參數還有一些限制，主要有以下幾點：


參數列表中不能有默認參數
不支持可變參數
所有參數必須有參數名
常用舉例：


複製代碼
   {
　　　 int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
        std::cout << "m:" << m << std::endl;            　　//輸出m:16


        std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;
//輸出n:9
        
//[capture list] (params list) -> return type {function body}
        auto gFunc = [](int x) -> function<int(int)> { return [=](int y) { return x + y; }; };
        auto lFunc = gFunc(4);
        std::cout << lFunc(5) << std::endl;

         //[capture list] (params list) {function body}
        auto hFunc = [](const function<int(int)>& f, int z) { return f(z) + 1; };
        auto a = hFunc(gFunc(7), 8);


        int a = 111, b = 222;
        auto func = [=, &b]()mutable { a = 22; b = 333; std::cout << "a:" << a << " b:" << b << std::endl; };


        func();
        std::cout << "a:" << a << " b:" << b << std::endl;


        a = 333;
        auto func2 = [=, &a] { a = 444; std::cout << "a:" << a << " b:" << b << std::endl; };
        func2();

        //[capture list] (params list) -> return type {function body}
        auto func3 = [](int x) ->function<int(int)> { return [=](int y) { return x + y; }; };


    　　//[capture list] (params list) {function body}
　　　　 std::function<void(int x)> f_display_42 = [](int x) { print_num(x); };
f_display_42(44);
　　}