Lambda 表達(dá)式

Lambda 表達(dá)式是現(xiàn)代 C++ 中最重要的特性之一，而 Lambda 表達(dá)式，實(shí)際上就是提供了一個(gè)類似匿名函數(shù)的特性， 而匿名函數(shù)則是在需要一個(gè)函數(shù)，但是又不想費(fèi)力去命名一個(gè)函數(shù)的情況下去使用的。這樣的場(chǎng)景其實(shí)有很多很多， 所以匿名函數(shù)幾乎是現(xiàn)代編程語(yǔ)言的標(biāo)配。

基礎(chǔ)

Lambda 表達(dá)式的基本語(yǔ)法如下：

[捕獲列表](參數(shù)列表) mutable(可選) 異常屬性 -> 返回類型 {
// 函數(shù)體
}

上面的語(yǔ)法規(guī)則除了 [捕獲列表] 內(nèi)的東西外，其他部分都很好理解，只是一般函數(shù)的函數(shù)名被略去， 返回值使用了一個(gè) -> 的形式進(jìn)行（我們?cè)谏弦还?jié)前面的尾返回類型已經(jīng)提到過(guò)這種寫法了）。

所謂捕獲列表，其實(shí)可以理解為參數(shù)的一種類型，Lambda 表達(dá)式內(nèi)部函數(shù)體在默認(rèn)情況下是不能夠使用函數(shù)體外部的變量的， 這時(shí)候捕獲列表可以起到傳遞外部數(shù)據(jù)的作用。根據(jù)傳遞的行為，捕獲列表也分為以下幾種：

1. 值捕獲

與參數(shù)傳值類似，值捕獲的前提是變量可以拷貝，不同之處則在于，被捕獲的變量在 Lambda 表達(dá)式被創(chuàng)建時(shí)拷貝， 而非調(diào)用時(shí)才拷貝：

void lambda_value_capture() {
    int value = 1;
    auto copy_value = [value] {
        return value;
    };
    value = 100;
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 這時(shí), stored_value == 1, 而 value == 100.
    // 因?yàn)?copy_value 在創(chuàng)建時(shí)就保存了一份 value 的拷貝
}

2. 引用捕獲

與引用傳參類似，引用捕獲保存的是引用，值會(huì)發(fā)生變化。

void lambda_reference_capture() {
    int value = 1;
    auto copy_value = [&value] {
        return value;
    };
    value = 100;
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 這時(shí), stored_value == 100, value == 100.
    // 因?yàn)?copy_value 保存的是引用
}

3. 隱式捕獲

手動(dòng)書寫捕獲列表有時(shí)候是非常復(fù)雜的，這種機(jī)械性的工作可以交給編譯器來(lái)處理，這時(shí)候可以在捕獲列表中寫一個(gè) & 或 = 向編譯器聲明采用引用捕獲或者值捕獲.

總結(jié)一下，捕獲提供了 Lambda 表達(dá)式對(duì)外部值進(jìn)行使用的功能，捕獲列表的最常用的四種形式可以是：

a. [] 空捕獲列表
b. [name1, name2, ...] 捕獲一系列變量
c. [&] 引用捕獲, 讓編譯器自行推導(dǎo)引用列表
d. [=] 值捕獲, 讓編譯器自行推導(dǎo)值捕獲列表

4. 表達(dá)式捕獲

這部分內(nèi)容需要了解后面馬上要提到的右值引用以及智能指針

上面提到的值捕獲、引用捕獲都是已經(jīng)在外層作用域聲明的變量，因此這些捕獲方式捕獲的均為左值，而不能捕獲右值。

C++14 給與了我們方便，允許捕獲的成員用任意的表達(dá)式進(jìn)行初始化，這就允許了右值的捕獲， 被聲明的捕獲變量類型會(huì)根據(jù)表達(dá)式進(jìn)行判斷，判斷方式與使用 auto 本質(zhì)上是相同的：

#include <iostream>
#include <memory>  // std::make_unique
#include <utility> // std::move
void lambda_expression_capture() {
    auto important = std::make_unique<int>(1);
    auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
        return x+y+v1+(*v2);
    };
    std::cout << add(3,4) << std::endl;
}

在上面的代碼中，important 是一個(gè)獨(dú)占指針，是不能夠被 "=" 值捕獲到，這時(shí)候我們可以將其轉(zhuǎn)移為右值，在表達(dá)式中初始化。

泛型 Lambda

上一節(jié)中我們提到了 auto 關(guān)鍵字不能夠用在參數(shù)表里，這是因?yàn)檫@樣的寫法會(huì)與模板的功能產(chǎn)生沖突。 但是 Lambda 表達(dá)式并不是普通函數(shù)，所以在沒(méi)有明確指明參數(shù)表類型的情況下，Lambda 表達(dá)式并不能夠模板化。 幸運(yùn)的是，這種麻煩只存在于 C++11 中，從 C++14 開始，Lambda 函數(shù)的形式參數(shù)可以使用 auto 關(guān)鍵字來(lái)產(chǎn)生意義上的泛型：

auto add = [](auto x, auto y) {
    return x+y;
};
add(1, 2);
add(1.1, 2.2);

函數(shù)對(duì)象包裝器

這部分內(nèi)容雖然屬于標(biāo)準(zhǔn)庫(kù)的一部分，但是從本質(zhì)上來(lái)看，它卻增強(qiáng)了 C++ 語(yǔ)言運(yùn)行時(shí)的能力， 這部分內(nèi)容也相當(dāng)重要，所以放到這里來(lái)進(jìn)行介紹。

std::function

Lambda 表達(dá)式的本質(zhì)是一個(gè)和函數(shù)對(duì)象類型相似的類類型（稱為閉包類型）的對(duì)象（稱為閉包對(duì)象）， 當(dāng) Lambda 表達(dá)式的捕獲列表為空時(shí)，閉包對(duì)象還能夠轉(zhuǎn)換為函數(shù)指針值進(jìn)行傳遞，例如：

#include <iostream>
using foo = void(int); // 定義函數(shù)類型, using 的使用見(jiàn)上一節(jié)中的別名語(yǔ)法
void functional(foo f) { // 參數(shù)列表中定義的函數(shù)類型 foo 被視為退化后的函數(shù)指針類型 foo*
    f(1); // 通過(guò)函數(shù)指針調(diào)用函數(shù)
}
int main() {
    auto f = [](int value) {
        std::cout << value << std::endl;
    };
    functional(f); // 傳遞閉包對(duì)象，隱式轉(zhuǎn)換為 foo* 類型的函數(shù)指針值
    f(1); // lambda 表達(dá)式調(diào)用
    return 0;
}

上面的代碼給出了兩種不同的調(diào)用形式，一種是將 Lambda 作為函數(shù)類型傳遞進(jìn)行調(diào)用， 而另一種則是直接調(diào)用 Lambda 表達(dá)式，在 C++11 中，統(tǒng)一了這些概念，將能夠被調(diào)用的對(duì)象的類型， 統(tǒng)一稱之為可調(diào)用類型。而這種類型，便是通過(guò) std::function 引入的。

C++11 std::function 是一種通用、多態(tài)的函數(shù)封裝， 它的實(shí)例可以對(duì)任何可以調(diào)用的目標(biāo)實(shí)體進(jìn)行存儲(chǔ)、復(fù)制和調(diào)用操作， 它也是對(duì) C++ 中現(xiàn)有的可調(diào)用實(shí)體的一種類型安全的包裹（相對(duì)來(lái)說(shuō)，函數(shù)指針的調(diào)用不是類型安全的）， 換句話說(shuō)，就是函數(shù)的容器。當(dāng)我們有了函數(shù)的容器之后便能夠更加方便的將函數(shù)、函數(shù)指針作為對(duì)象進(jìn)行處理。 例如：

#include <functional>
#include <iostream>
int foo(int para) {
    return para;
}
int main() {
    // std::function 包裝了一個(gè)返回值為 int, 參數(shù)為 int 的函數(shù)
    std::function<int(int)> func = foo;
    int important = 10;
    std::function<int(int)> func2 = [&](int value) -> int {
        return 1+value+important;
    };
    std::cout << func(10) << std::endl;
    std::cout << func2(10) << std::endl;
}
std::bind 和 std::placeholder

而 std::bind 則是用來(lái)綁定函數(shù)調(diào)用的參數(shù)的， 它解決的需求是我們有時(shí)候可能并不一定能夠一次性獲得調(diào)用某個(gè)函數(shù)的全部參數(shù)，通過(guò)這個(gè)函數(shù)， 我們可以將部分調(diào)用參數(shù)提前綁定到函數(shù)身上成為一個(gè)新的對(duì)象，然后在參數(shù)齊全后，完成調(diào)用。 例如：

int foo(int a, int b, int c) {
    ;
}
int main() {
    // 將參數(shù)1,2綁定到函數(shù) foo 上，
    // 但使用 std::placeholders::_1 來(lái)對(duì)第一個(gè)參數(shù)進(jìn)行占位
    auto bindFoo = std::bind(foo, std::placeholders::_1, 1,2);
    // 這時(shí)調(diào)用 bindFoo 時(shí)，只需要提供第一個(gè)參數(shù)即可
    bindFoo(1);
}

提示：注意 auto 關(guān)鍵字的妙用。有時(shí)候我們可能不太熟悉一個(gè)函數(shù)的返回值類型， 但是我們卻可以通過(guò) auto 的使用來(lái)規(guī)避這一問(wèn)題的出現(xiàn)。

到此這篇關(guān)于C++ lambda函數(shù)詳解的文章就介紹到這了,更多相關(guān)C++ lambda內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論