C++11的lambda表达式

        lambda来源于函数式编程的概念。C++11这次终于把lambda加进来了。

        lambda表达式有如下优点:

        1、声明式编程风格:就地匿名定义目标函数或函数对象,不需要额外写一个命名函数或者函数对象。以更直接的方式去写程序,好的可读性和可维护性。

        2、简洁:不需要额外再写一个函数或者函数对象,避免了代码膨胀和功能分散,让开发者更加集中精力在手边的问题,同时也获取了更高的生产率。

        3、在需要的时间和地点实现功能闭包,使程序更灵活。

lambda表达式的概念和基本用法

        lambda表达式定义了一个匿名函数,并且可以捕获一定范围内的变量。lambda表达式的语法形式可简单归纳如下:

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

        其中:capture是捕获列表;params是参数表;opt是函数选项;ret是返回值类型;body是函数体。

        因此,一个完整的lambda表达式看起来像这样:
 

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

        cout << f(1) << endl;                //输出:2

        可以看到,上面通过一行代码定义了一个小小闭包,用来输入加1并返回。

        在C++11中,lambda表达式的返回值是通过前面介绍的返回值后置语法来定义的。其实很多时候,lambda表达式的返回值是非常明显的,比如上例。因此,C++11中运行省略lambda表达式的返回值定义:

       

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

        这样编译器就会根据return语句自动推导出返回值类型。

        需要注意的是,初始化列表不能用于返回值的自动推导。
 

        auto x1 = [](int i){ return i; };         //OK:return type is int

        auto x2 = [](){ return {1, 2};};        // error:无法推导出返回值类型

        这时我们需要显示给出具体的返回值类型。

        另外,lambda表达式在没有参数列表时,参数列表是可以省略的。因此像下面的写法都是正确的:
 

        auto f1 = [] () { return 1; };

        auto f2 = [] { return 1; };         //省略空参数表

        lambda表达式可以通过捕获列表捕获一定范围的变量:

        1、[]不捕获任何变量。

        2、[&]捕获外部作用域中所有变量,并作为引用在函数体中使用(按引用捕获)。

        3、[=]捕获外部作用域中所有变量,并作为副本在函数体中使用(按值捕获)。

        4、[=, &foo]按值捕获外部作用域中所有变量,并按引用捕获foo变量。

        5、[bar]按值捕获bar变量,同时不捕获其他变量。

        6、[this]捕获当前类中的this指针,让lambda表达式拥有和当前类成员函数同样的访问权限。如果已经使用了&或者=,就默认添加此选项。捕获this的目的是可以在lambda中使用当前类的成员函数和成员变量。

lambda表达式基本用法

#include 
using namespace std;

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 main()
{
    int a = 0, b = 1;

    auto f1 = [] { return a; };     ///error,没有捕获外部变量

    auto f2 = [&] { return a++; };  ///OK,捕获所有外部变量,并对a执行自加运算

    auto f3 = [=] { return a; };    ///OK,捕获所有外部变量,并返回a

    auto f4 = [=] { return a++; };  ///error,a是以复制方式捕获的,无法修改

    auto f5 = [a] { return a + b; };    ///error,没有捕获变量b

    auto f6 = [a, &b] { return a + (b++); };    ///OK,捕获a和b的引用,并对b做自加运算

    auto f7 = [=, &b] { return a + (b++); };    ///OK,捕获所有外部变量和b的引用,并对b做自加运算

    return 0;
}

        从上例中可以看到,lambda表达式的捕获列表精细的控制了lambda表达式能够访问的外部变量,以及如何访问这些变量。

        需要注意的是,默认状态下lambda表达式无法修改通过复制方式捕获的外部变量。如果希望修改这些变量的话,我们需要使用引用方式进行捕获。

    int a = 0;
    auto f = [=] { return a; };

    a += 1;

    cout << f() << endl;

        在这个例子中,lambda表达式按值捕获了所有外部变量。在捕获的一瞬间,a的值就已经被复制到f中了。之后a被修改了,但此时f中存储的a仍然还是捕获时的值,因此,最终输出结果是0。

        如果希望lambda表达式在调用时能够及时访问外部变量,我们应当使用引用方式捕获。

        如果希望去修改按值捕获的外部变量,需要显示指明lambda表达式为mutable:

int main()
{
    int a = 0;

    ///auto f1 = [=](){ return a++; };          ///error,修改按值捕获的外部变量
    auto f2 = [=]()mutable { return a++; };     ///OK,mutable

    return 0;
}

        需要注意的一点是,被mutable修改的lambda表达式就算没有参数也要写明参数列表。

        lambda表达式的类型在C++11中被称为“闭包类型”。它是一个特殊的,匿名的非nunion的类型。因此,我们可以认为它是一个带有operator()的类,即仿函数。因此,我们可以使用std::function和std::bind来存储和操作lambda表达式:

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

        另外,对于没有捕获任何变量的lambda表达式,还可以被转换成一个普通的函数指针:

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

        lambda表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量,最终均会变成闭包类型的成员变量。而一个使用了成员变量的类的operator(),如果能直接被转换为普通的函数指针,那么lambda表达式本身的this指针就会丢失掉。而没有捕获任何外部变量的lambda表达式则不存在这个问题。

        这里也可以很自然的解释为何按值捕获无法修改捕获的外部变量。因为按照C++标志,lambda表达式的operator()默认是const的。一个const成员函数是无法修改成员变量的值的。而mutable的作用,就在于取消operator()的const。

声明式的编程风格,简洁的代码

        就地定义匿名函数,不再需要定义函数对象,大大简化了标准库算法的调用。在C++11之前,我们要调用for_each函数将vector中的偶数打印出来,代码如下所示:

    
#include 
#include 
#include 
#include 
using namespace std;

class CountEven
{
public:
    CountEven(int& c):count(c){}

    void operator()(int val)
    {
        if (!(val & 1))
        {
            ++count;
        }
    }

private:
    int& count;
};

int main()
{
    int count = 0;
    vector v = {1, 2, 3, 4, 5, 6, 7, 8};

    for_each(v.begin(), v.end(), CountEven(count));

    cout << "The number of even is " << count << endl;

    return 0;
}

        这样写既繁琐又容易出错。有了lambda表达式以后,我们可以使用真正的闭包概念来替换这里的仿函数,代码如下所示:

        


#include 
#include 
#include 
#include 
using namespace std;

class CountEven
{
public:
    CountEven(int& c):count(c){}

    void operator()(int val)
    {
        if (!(val & 1))
        {
            ++count;
        }
    }

private:
    int& count;
};

int main()
{
    int count = 0;
    vector v = {1, 2, 3, 4, 5, 6, 7, 8};

    for_each(v.begin(), v.end(), CountEven(count));

    cout << "The number of even is " << count << endl;

    count = 0;
    for_each(v.begin(), v.end(), [&count](int val)
            {
                if (!(val & 1))
                {
                    ++ count;
                }
            }
            );

    cout << "The number of even is " << count << endl;

    return 0;
}

        lambda表达式的价值在于,就地封装短小的功能闭包,可以及其方便的表达出我们希望执行的具体操作,并让上下文结合得更加紧密。

你可能感兴趣的:(C++11,c++,开发语言)