前言

Lambda（匿名函數(shù)）表達(dá)式是C++11最重要的特性之一，lambda來源于函數(shù)式編程的概念，也是現(xiàn)代編程語言的一個(gè)特點(diǎn)。

優(yōu)點(diǎn)如下：

• 聲明式編程風(fēng)格：就地匿名定義目標(biāo)函數(shù)或函數(shù)對(duì)象，有更好的可讀性和可維護(hù)性。
• 簡(jiǎn)潔：不需要額外寫一個(gè)命名函數(shù)或函數(shù)對(duì)象，，避免了代碼膨脹和功能分散。
• 更加靈活：在需要的時(shí)間和地點(diǎn)實(shí)現(xiàn)功能閉包。

概念及基本用法

lambda表達(dá)式定義了一個(gè)匿名函數(shù)，并且可以捕獲一定范圍內(nèi)的變量。語法形式如下：

[ capture ] ( params ) opt -> ret { body; };

• capture：捕獲列表
• params：參數(shù)列表
• opt：函數(shù)選項(xiàng)
• ret：返回值類型
• body：函數(shù)體

一個(gè)完整的lambda表達(dá)式是這樣：

auto f = [](int a) -> int {return a + 1;};
cout << f(3) << endl;  //輸出4

以上定義了一個(gè)完整的lambda，但是在實(shí)際的使用中，可以省略其返回值的定義，編譯器會(huì)根據(jù)return語句進(jìn)行自動(dòng)推導(dǎo)返回值類型。

省略過后如下：

auto f = [](int a) {return a + 1;};

需要注意的是，初始化列表不能用于返回值的自動(dòng)推導(dǎo)：

如：auto f = [](){return {1,2};}; //error:無法推導(dǎo)返回值類型

另外，如果表達(dá)式?jīng)]有參數(shù)列表時(shí)，也可以省略，如：

auto f = []{return 1;};

捕獲變量

lambda表達(dá)式可以通過捕獲列表捕獲一定范圍內(nèi)的變量，主要有以下幾種情況：

• [] 不捕獲任何變量
• [&]捕獲外部作用域中所有變量，并作為引用在函數(shù)體中使用（按引用捕獲）
• [=]捕獲外部作用域中所有變量，并作為副本在函數(shù)體重使用（按值捕獲）
• [=,&foo] 按值捕獲外部作用域中所有變量，并按引用捕獲foo變量
• [bar] 按值捕獲bar變量，同時(shí)不捕獲其他變量
• [this] 捕獲當(dāng)前類中的this指針，讓表達(dá)式擁有和當(dāng)前類成員函數(shù)同樣的訪問權(quán)限。如果已經(jīng)使用了&或者=，就默認(rèn)添加此選項(xiàng)。捕獲this的目的是可以在lambda中使用當(dāng)前類的成員變量和成員函數(shù)。

通過示例來看具體用法：

class A 
{
public:
    int i_ = 0;
    
    void func(int x,int y)
    {
        auto x1 = []{return i_;};  // error,沒有捕獲外部變量
        auto x2 = [=]{return i_ + x + y;}; //ok，按值捕獲所有外部變量
        auto x3 = [&]{return i_ + x + y;}; //ok，按引用捕獲所有外部變量
        auto x4 = [this]{return i_;}; //ok，捕獲this指針
        auto x5 = [this]{return i_ + x + y;}; //error,沒有捕獲x和y變量
        auto x6 = [this,x,y]{return i_ + x + y;}; //ok，捕獲了this指針和x、y變量
        auto x7 = [this]{return i_++;}; //ok，捕獲了this指針，修改成員變量的值
    }
};

int a = 0 , b = 0 ;
auto f1 = []{return a;}; // error,沒有捕獲外部變量
auto f2 = [&]{return a++;}; //ok，捕獲所有外部變量，并對(duì)a變量自加
auto f3 = [=]{return a;}; //ok，捕獲所有外部變量，并返回a
auto f4 = [=]{return a++;}; //error,a變量是以復(fù)制方式捕獲的，不能修改
auto f5 = [a]{return a+b;}; //error,沒有捕獲b變量
auto f6 = [a,&b]{return a+ (b++);}; //ok，捕獲a以及b的引用，對(duì)b進(jìn)行自加
auto f7 = [=,&b]{return a+ (b++);}; //ok, 捕獲所有外部變量和b的引用，對(duì)b進(jìn)行自加

需要注意的是，lambda無法修改按值捕獲的外部變量，如果需要修改外部變量，可以通過引用方式捕獲。

關(guān)于lambda表達(dá)式的延遲調(diào)用很容易出錯(cuò),如下：

int a = 0;
auto f = [=]{return a;};
a += 1;
cout << f() << endl;

以上示例中，lambda按值捕獲了所有外部變量，在捕獲的時(shí)候 a的值就已經(jīng)被復(fù)制到 f 中了，之后a被修改，但是f里面存儲(chǔ)的a仍然是捕獲時(shí)的值，所以最終輸出的是 0.

如果希望lambda表達(dá)式在調(diào)用的時(shí)候能夠訪問外部變量，需要使用引用方式捕獲。

所以簡(jiǎn)單來說，按值捕獲，外部變量會(huì)被復(fù)制一份存儲(chǔ)在lambda表達(dá)式變量中。

如果是按值捕獲并且又想修改外部變量，可以顯示指明lambda表達(dá)式為mutable：

int a = 0;
auto f1 = [=]{return a++;};  //error,修改按值捕獲的外部變量
auto f2 = [=]() mutable {return a++;}; //ok

被mutable修飾的lambda表達(dá)式就算沒有參數(shù)也要寫明參數(shù)列表。

lambda表達(dá)式類型

lambda表達(dá)式的類型在C++11中被稱為“閉包類型”，它是一個(gè)特殊的，匿名的非nunion的類型。

可以認(rèn)為它是帶有一個(gè)operator()的類，即仿函數(shù)。
我們可以通過std::function和std::bind來存儲(chǔ)和操作lambda表達(dá)式：

std::function<int(int)> f1 = [](int a){return a;};
std::function<int(void)> f2 = std::bind([](int a){return a;},123);

另外，對(duì)于沒有捕獲任何變量的lambda表達(dá)式，還可以被轉(zhuǎn)換成一個(gè)普通的函數(shù)指針：

using func_t = int(*)(int);
func_t f = [](int a){return a;};
f(123);

lambda可以說是就地定義仿函數(shù)閉包的“語法 糖”。它的捕獲列表捕獲住任何外部變量，最終都會(huì)變?yōu)殚]包類型的成員變量。而一個(gè)成員變量的類的operator()，如果能直接被轉(zhuǎn)換為普通的函數(shù)指針，那么lambda表達(dá)式本身的this指針就丟掉了。而沒有捕獲任何外部變量的lambda表達(dá)式則不存在這個(gè)問題。

需要注意的是，沒有捕獲變量的lambda表達(dá)式可以直接轉(zhuǎn)換為函數(shù)指針，而捕獲變量的lambda表達(dá)式則不能轉(zhuǎn)換為函數(shù)指針。如下：

typedef void(*Ptr)(int*);
Ptr p = [](int *p){delete p;};  //ok
Ptr p1 = [&](int *p){delete p;}; //error

前面說到的按值捕獲無法修改捕獲的外部變量，因?yàn)榘凑誄++標(biāo)準(zhǔn)，lambda表達(dá)式的operator()默認(rèn)是const的，一個(gè)const成員函數(shù)是無法修改成員變量的值，而mutable的作用，就是取消operator()的const限制。

聲明式的編程風(fēng)格

通過示例來看一下lambda的使用，在C++11之前，如果要用for_each函數(shù)將數(shù)組中的偶數(shù)數(shù)量打印出來，代碼如下：

#include <vector>
#include <algorithm>
class Count
{
public:
? ? Count(int &val):num(val){}
? ? void operator()(int val){
? ? ? ? if(!(val & 1)){
? ? ? ? ? ? ++num;
? ? ? ? }
? ? }
private:
? ? int &num;
};

int main()
{
? ? std::vector<int> v = {1,2,3,4,5,6,7};
? ? int count = 0;
? ? for_each(v.begin(),v.end(),Count(count));
? ? std::cout << count << endl;
? ? return 0;
}

如果使用lambda表達(dá)式，就可以簡(jiǎn)化一下，真正使用閉包概念來替換這里的仿函數(shù)。

#include <vector>
#include <algorithm>

int main()
{
    std::vector<int> v = {1,2,3,4,5,6,7};
    int count = 0;
    for_each(v.begin(),v.end(),[&count](int val){
        if(!(val & 1)){
            ++count;
        }
    });

    std::cout << count << endl;
    return 0;
}

lambda表達(dá)式的價(jià)值在于，就地封裝短小的功能閉包，方便地表達(dá)出我們希望執(zhí)行的具體操作，并讓上下文結(jié)合的更加緊，代碼更加簡(jiǎn)潔，更靈活，也提高了開發(fā)效率及可維護(hù)性。

參考：《深入應(yīng)用C++11》

總結(jié)

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

最新評(píng)論