C++11—lambda函数

【1】lambda表达式语法

lambda表达式的语法定义如下：

[capture]（parameters）mutable ->return-type { statement };

（1）[capture]: 捕捉列表。捕捉列表总是出现在lambda函数的开始处。实质上，[]是lambda引出符（即独特的标志符）

编译器根据该引出符判断接下来的代码是否是lambda函数

捕捉列表能够捕捉上下文中的变量以供lambda函数使用

捕捉列表由一个或多个捕捉项组成，并以逗号分隔，捕捉列表一般有以下几种形式：

<1> [var] 表示值传递方式捕捉变量var

<2> [=] 表示值传递方式捕捉所有父作用域的变量（包括this指针）

<3> [&var] 表示引用传递捕捉变量var

<4> [&] 表示引用传递捕捉所有父作用域的变量（包括this指针）

<5> [this] 表示值传递方式捕捉当前的this指针

<6> [=，&a，&b] 表示以引用传递的方式捕捉变量 a 和 b，而以值传递方式捕捉其他所有的变量

<7> [&，a，this] 表示以值传递的方式捕捉 a 和 this，而以引用传递方式捕捉其他所有变量

备注：父作用域是指包含lambda函数的语句块

另外，需要注意的是，捕捉列表不允许变量重复传递。下面的例子就是典型的重复，会导致编译错误：

[=, a] 这里 = 已经以值传递方式捕捉了所有的变量，那么再捕捉 a 属于重复

[&，&this] 这里 & 已经以引用传递方式捕捉了所有变量，那么再捕捉 this 属于重复

（2）（parameters）: 参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号（）一起省略

（3）mutable : mutable修饰符。默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性（后面有详解）

在使用该修饰符时，参数列表不可省略（即使参数为空）

（4）->return-type : 返回类型。用追踪返回类型形式声明函数的返回类型。

出于方便，不需要返回值的时候也可以连同符号->一起省略

此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导

（5）{statement} : 函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量

在lambda函数的定义中，参数列表和返回类型都是可选的部分，而捕捉列表和函数体都可能为空

那么，在极端情况下，C++11中最为简单的lambda函数只需要声明为：

[]{};

就可以了。不过显然，这样的lambda函数不能做任何事情（乍一看好漂亮，其实仅是好看）。

【2】lambda函数示例代码

示例代码1：

#include <iostream>
using namespace std;

void main()
{
    int a = 20, b = 10;

    auto totalAB = [] (int x, int y)->int { return x + y; };
    int aAddb = totalAB(a, b);
    cout << "aAddb :" << aAddb << endl;

    auto totalAB2 = [a, &b]()->int { return a + b; };
    int aAddb2 = totalAB2();
    cout << "aAddb2 :" << aAddb2 << endl;

    auto totalAB3 = [=]()->int { return a + b; };
    int aAddb3 = totalAB3();
    cout << "aAddb3 :" << aAddb3 << endl;

    []{}; // 最简lambda函数
    [=] { return a + b; }; // 省略了参数列表与返回类型，返回类型由编译器推断为int
    auto fun1 = [&] (int c) { b = a + c; }; // 省略了返回类型，无返回值
    auto fun2 = [=, &b](int c)->int { return b += a + c; }; // 各部分都很完整的lambda函数
    cout << "fun2(100) :" << fun2(100) << endl;
}
// Result:
/*
aAddb :30
aAddb2 :30
aAddb3 :30
fun2(100) :130
*/

以上代码仅供学习参考

【3】lambda函数的作用

lambda函数的使用示例代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include "time.h"
using namespace std;

void main()
{
    vector<int> nVec;
    for (int i = 0; i < 100000; ++i)
    {
        nVec.push_back(i);
    }

    double time_Start = (double)clock();
    for (vector<int>::const_iterator it = nVec.begin(); it != nVec.end(); ++it) 
    {
        cout << *it << endl;
    }
    double time_Finish = (double)clock();
    double time_Interval_1 = (double)(time_Finish - time_Start) / 1000;
    
    time_Start = (double)clock();
    for_each( nVec.begin(), nVec.end(), [] (int val){ cout << val << endl; } );
    time_Finish = (double)clock();
    double time_Interval_2 = (double)(time_Finish - time_Start) / 1000;

    cout << "time_Interval_1 :" << time_Interval_1 << endl;
    cout << "time_Interval_2 :" << time_Interval_2 << endl;

}
// Result:
/*
time_Interval_1 :17.748
time_Interval_2 :17.513
*/

lambda函数的引入为STL的使用提供了极大的方便。同样是遍历容器，效率反而提高了很多。

【4】lambda函数 与 仿函数

何谓仿函数？个人理解，像函数一样工作的对象。

根据面向对象的编程思想，那么问题来了！既然主语是一个对象，创建这个对象的类长什么样子呢？

据听说，所有科学中数学学科最重要，语文重要性次之。为什么呢？

数学可以利用来解决问题，但当问题解决不了的时候，可以用语文涂画，涂画得让人听不懂。好像很高大上一样一样~

关于仿函数，请看下面示例：

#include <iostream>
using namespace std;

class _functor_plus
{
private:
    int m_nValue;

public:
    _functor_plus(int nValue = 100);
    _functor_plus operator+ (const _functor_plus & funObj);
    void printInfo();
};

_functor_plus::_functor_plus(int nValue) : m_nValue(nValue)
{
}

_functor_plus _functor_plus::operator+ (const _functor_plus & funObj)
{
    m_nValue += funObj.m_nValue;
    return _functor_plus(m_nValue);
}

void _functor_plus::printInfo()
{
    cout << m_nValue << endl;
}

class _functor_override
{
public:
    int operator()(int x, int y);
};

int _functor_override::operator()(int x, int y)
{
    return x + y;
}

int main()
{
    _functor_plus plusA, plusB, plusC;
    plusC = plusA + plusB;
    plusA.printInfo();
    plusB.printInfo();
    plusC.printInfo();

    int boys = 4, girls = 3;
    _functor_override totalChildren;
    cout << "totalChildren(int, int): " << totalChildren(boys, girls);
}
// Result:
/*
200
100
200
totalChildren(int, int): 7
*/

在这个例子中，_functor_override类的operator（）被重载。

因此，在调用该函数的时候，我们看到与函数调用一样的形式。

只不过这里的totalChildren不是函数名称，而是一个对象名称。

相比于函数，仿函数可以拥有初始化状态：

一般通过class定义私有成员，并在声明对象的时候对其进行初始化，

那般，私有成员的状态就成了仿函数的初始状态。

由于声明一个仿函数对象可以拥有多个不同的初始状态的实例，

因此，可以借由仿函数产生多个功能类似实质却各不同的仿函数实例。

请参见下例：

#include <iostream>
using namespace std;

class Tax
{
private:
    double m_dRate;
    int m_nBase;

public:
    Tax(double dRate, int nBase) : m_dRate(dRate), m_nBase(nBase)
    {
    }

    double operator() (double dMoney)
    {
        return (dMoney - m_nBase) * m_dRate;
    }
};

int main()
{
    Tax high(0.40, 30000);
    Tax middle(0.25, 20000);
    cout << "tax over 3w: " << high(37500) << endl;
    cout << "tax over 2w: " << middle(24000) << endl;
}
// Result:
/*
tax over 3w: 3000
tax over 2w: 1000
*/

到这里，是否发现仿函数和lambda之间存在一种“衍生”的关系？

难道还不明显？没看懂？咱再接着剖析，谁让程序员就这么理性呢？

请再看下例：

#include <iostream>
using namespace std;

class AirportPrice
{
private:
    double m_dDutyfreeRate;

public:
    AirportPrice(double dDutyfreeRate) : m_dDutyfreeRate(dDutyfreeRate)
    {}

    double operator() (double dPrice)
    {
        return dPrice * (1 - m_dDutyfreeRate/100);
    }
};

void main()
{
    double dRate = 5.5;
    AirportPrice fanFunObj(dRate);

    auto ChangLambda = [dRate](double dPrice)->double
    {
        return dPrice * (1 - dRate/100);
    };
    double purchased1 = fanFunObj(3699);
    double purchased2 = ChangLambda(3699);
    cout << "purchased1:" << purchased1 << endl;
    cout << "purchased2:" << purchased2 << endl;
}
// Result:
/*
purchased1:3495.55
purchased2:3495.55
*/

分别使用了仿函数和lambda两种方式来完成扣税后的产品价格计算。

lamba函数捕捉了dRate变量，而仿函数则以dRate进行初始化类。

其他的，在参数传递上，两者保持一致，结果也一致。

可以看到，除去在语法层面的差异，lambda函数和仿函数有着相同的内涵：

即都可以捕捉一些变量作为初始化状态，并接受参数进行运算。

而事实上，仿函数正是编译器实现lambda的一种方式。

在现阶段，通常编译器都会把lambda函数转化为一个仿函数对象。

因此，C++11中，lambda可以视为仿函数的一种等价形式。

备注：有时，编译时发现lambda函数出现了错误，编译器会提示一些构造函数相关的信息，

显然是由于lambda的这种实现方式造成的。理解这种实现也能够正确理解错误信息的由来。

【5】lambda函数等同于一个局部函数

局部函数，在函数作用域中定义的函数，也称为内嵌函数。

局部函数通常仅属于其父作用域，能够访问父作用域的变量。

C/C++语言标准中不允许局部函数存在（FORTRAN语言支持）

C++11标准却用比较优雅的方式打破了这个规则。

因为事实上，lambda可以像局部函数一样使用。请参见下例：

#include <iostream>
using namespace std;

extern int z = 100;
extern float c = 100.00;

void Calc(int& rnOne, int nTwo, float& rfThree, float fFour)
{
    rnOne = nTwo;
    rfThree = fFour;
}

void TestCalc()
{
    int x, y = 3;
    float a, b = 4.0;
    int success = 0;

    auto validate = [&]()->bool
    {
        if ((x == y + z) && (a == b + c))
            return 1;
        else
            return 0;
    };

    Calc(x, y, a, b);
    success += validate();

    y = 1024;
    b = 100.0;
    Calc(x, y, a, b);
    success += validate();
}

void main()
{
}

在没有lambd函数之前，通常需要在TestCalc外声明同样一个函数，

并且把TestCalc中的变量当作参数进行传递。

出于函数作用域及运行效率的考虑，那样声明函数通常要加上关键字static 和 inline

相比于一个传统意义上的函数定义，lambda函数在这里直观，使用方便可读性很好。请参见下例：

#include <iostream>
using namespace std;

int Prioritize(int nValue)
{
    return nValue + 10;
}

int  AllWorks(int nTimes)
{
    int i = 0, x = 0;
    try
    {
        for (i = 0; i < nTimes; ++i)
        {
            x += Prioritize(i);
        }
    }
    catch (...)
    {
        x = 0;
    }

    const int y = [=]()->int
    {
        int i = 0, val = 0;
        try
        {
            for (; i < nTimes; ++i)
            {
                val += Prioritize(i);
            }
        }
        catch (...)
        {
            val = 0;
        }
        return val;
    }();
    // lambda表达式
    {
        []{}();
        [](){}();
        []{ cout << "emptyLambdaExec" << endl; }();
        [=](){ cout << "const int y :" << y << endl; }();
        [&](){ cout << "int x :" << x << endl; }();
    }

    return 0;
}

void main()
{
    AllWorks(10);
}

// Result:
/*
emptyLambdaExec
const int y :145
int x :145
*/

备注：注意此例中的lambda表达式作用域中比较特殊的几个lambda函数。

【6】关于lambda的一些问题及其有趣的测试

（1）使用lambda函数时候，不同的捕捉方式会导致不同的结果：

请看下例：

#include <iostream>
using namespace std;

void main()
{
    int j = 10;
    auto by_val_lambda = [=] { return j + 1; };
    auto by_ref_lambda = [&] { return j + 1; };
    cout << "by_val_lambda: " << by_val_lambda() << endl;
    cout << "by_ref_lambda: " << by_ref_lambda() << endl;
    ++j;
    cout << "by_val_lambda: " << by_val_lambda() << endl;
    cout << "by_ref_lambda: " << by_ref_lambda() << endl;
}

//Result:
/*
by_val_lambda: 11
by_ref_lambda: 11
by_val_lambda: 11
by_ref_lambda: 12
*/

充分说明了传值和引用方式的区别。

（2）使用lambda函数与函数指针

一般情况下，把匿名的lambda函数赋值给一个auto类型的变量，

这是一种声明和使用lambda函数的方法。

结合关于auto的知识，有人会猜测totalChild是一种函数指针类型的变量

结合lambda函数和仿函数之间关系，大多人会倾向于认为lambda是一种自定义类型。

实质上，lambda的类型并非简单函数指针类型或自定义类型。

从C++11标准定义发现，lambda类型被定义为“闭包”的类，而每一个lambda表达式则会产生一个闭包类型的临时对象。

也因此，严格地讲，lambda函数并非函数指针。

但是，C++11标准却允许lambda表达式向函数指针的转换，

前提是lambda函数没有捕捉任何变量，且函数指针所示的函数原型，必须跟lambda函数有着相同的调用方式。

#include <iostream>
using namespace std;

void main()
{
    int girs = 3, boys = 4;
    auto totalChild = [](int x, int y)->int{ return x + y; };
    typedef int (*pFunAll)(int x, int y);
    typedef int (*pFunOne)(int x);

    pFunAll funAll;
//  funAll = totalChild; // 编译失败！

    pFunOne funOne;
//  funOne = totalChild; //编译失败！参数必须一致

    decltype(totalChild) allPeople = totalChild; // 需通过decltype获得lambda的类型
//  decltype(totalChild) totalPeople = funAll; // 编译失败，指针无法转换lambda
}

第 12 行，编译错误信息如下：

error C2440: “=”: 无法从“`anonymous-namespace'::<lambda0>”转换为“pFunAll”　　

 　　　　　　　　没有可用于执行该转换的用户定义的转换运算符，或者无法调用该运算符

MSVC10环境下，第一步编译不通过。

关于此问题参见文章《在 MSVC10 下，將 lambda expression 轉換成 C 的 function pointer》

第 15 行 编译失败，参数不一致

第 18 行 编译失败，函数指针转换为lambda也是不成功的。

值得注意的是，可以通过decltype的方式获取lambda函数的类型。

（3）lambda函数的常量性以及mutable关键字

C++11中，默认情况下lambda函数是一个const函数。

神马意思呢？请参见下例：

#include <iostream>
using namespace std;

class const_val_lambda
{
public:
    const_val_lambda(int v) : m_nVal(v)
    {}
public:
    void operator() () const
    {
//        m_nVal = 3;  /*注意：常量成员函数*/ 
    }

    void ref_const_Fun(int& nValue) const
    {
        nValue = 100;
    }

private:
    int m_nVal;
};

void main()
{
    int val = 10;
    // 编译失败！在const的lambda中修改常量
//    auto const_val_lambda = [=]() { val = 3;}; // 不能在非可变 lambda 中修改按值捕获
    // 非const的lambda,可以修改常量数据
    auto mutable_val_lambda = [=]() mutable{ val = 3; };
    // 依然是const的lambda,不过没有改动引用本身
    auto const_ref_lambda = [&] { val = 3; };
    // 依然是const的lambda,通过参数传递val
    auto const_param_lambda = [&](int varA) { varA = 3;};
    const_param_lambda(val);
}

备注：使用引用方式传递的变量在常量成员函数中修改值并不会导致错误。

【7】lambda 与 STL

lambda对C++11最大的贡献，或者说改变，应该在STL库中

相关应用，具体请再参见下例：

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

const int ubound = 3;

vector<int> nums;
vector<int> largeNums;

void initNums()
{
    for (int i = 1; i < 5; ++i)
    {
        nums.push_back(i);
    }
}

inline void largeNumsFunc(int i)
{
    if (i > ubound)
    {
        largeNums.push_back(i);
    }
}

void filter()
{
    for (auto it = nums.begin(); it != nums.end(); ++it)
    {
        if ((*it) > ubound)
        {
            largeNums.push_back(*it);
        }
    }

    for_each (nums.begin(), nums.end(), largeNumsFunc);

    for_each (nums.begin(), nums.end(), [=](int i)
    {
        if (i > ubound)
        {
            largeNums.push_back(i);
        }
    });
}

void printInfo()
{
    for_each (largeNums.begin(), largeNums.end(), [=](int i)
    {
        cout << i << " ";
    });
    cout << endl;
}

void main()
{
    initNums(); // 初始化值
    filter(); // 过滤值
    printInfo(); //打印信息
}

具体遇到其它的问题 ，再具体分析和学习。

【8】在返回类型明确的情况下，可以省略返回值类型，让编译器对返回类型进行推导

第一部分第4小节：“此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导”，示例如下：

#include <iostream>
#include <string>

int main()
{
    std::string str = "user_behavior_log";
    auto key = [&]() {
        if (str.empty())
        {
            return std::string{};
        }

        return (str + ".json");
    };

    std::cout << key() << std::endl;

    return 0;
}

// result
/*
user_behavior_log.json
*/

希望能加深对返回类型的理解。

【9】lambda函数的总结

C++11中的Lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。