lambda表达式

c++11引入lambda表达式,再配合 for_each,transform 等函数,有了函数式编程的能力。

语法格式

1.  [ captures ] ( params ) specifiers exception -> ret { body }
2.  [ captures ] ( params ) -> ret { body }
3.  [ captures ] ( params ) { body }
4.  [ captures ] { body }

这四种格式表达的意思是:

1. 完整声明
2. const类型的表达式,这种类型的表达式不能修改捕获列表中的值
3. 省略了返回值类型,就像是一个返回值是auto的普通函数一样,编译器可以根据以下规则推断出Lambda表达式的返回类型: 
  (1). 如果function body中存在return语句,则该Lambda表达式的返回类型由return语句的返回类型确定;
  (2). 如果function body中没有return语句,则返回值为void类型。 4. 省略了参数列表,类似普通函数中的无参函数。

解释

1. capture -- 捕获外部变量列表。多个变量使用逗号分隔。

2. params -- 形参列表。不能使用默认参数,不能使用auto类型的参数,参数必须有参数名

3. specifiers -- c++11只能使用 mutable,表示允许函数体修改值捕获的变量; 运行调用非const类型的成员函数

4. exception -- 异常声明或者noexcept

5. ret -- 返回类型

6. body -- 函数体

使用方法

#include <vector>
#include <algorithm>
#include <iostream>


bool getSqu(int a)
{
    return !(a & (a-1));
}

int main()
{
    std::vector<int> v {6,7,5,3,7,7,8,9};

    auto res = std::find_if(v.begin(), v.end(), getSqu); // 原来的做法,需要定义一个函数getSqu
    std::cout << *res << std::endl;

    res = std::find_if(v.begin(), v.end(), [](int a){   // 直接使用闭包
        return !(a & (a-1));
    });
    std::cout << *res << std::endl;

    return 0;
}

在C++11之前,我们使用STL的find_if函数,需要提供一个谓词函数。如果使用C++11的Lambda表达式,我们只需要传入一个匿名函数即可,方便简洁,而且代码的可读性也比旧式的做法好多了。

捕获外部变量

Lambda表达式可以使用其可见范围内的外部变量,但必须明确声明(明确声明哪些外部变量可以被该Lambda表达式使用)。那么,在哪里指定这些外部变量呢?Lambda表达式通过在最前面的方括号 [] 来明确指明其内部可以访问的外部变量,这一过程也称过Lambda表达式“捕获”了外部变量。

#include <iostream>


int main()
{
    int a = 98;

    auto f = [a]{ std::cout << a << std::endl; };
    f();

   // 类似传入参数 auto f2
= [](int a) { std::cout << a << std::endl; }; f2(a); return 0; }

上面这个例子先声明了一个整型变量a,然后再创建Lambda表达式,该表达式“捕获”了a变量,这样在Lambda表达式函数体中就可以获得该变量的值。

类似参数传递方式(值传递、引入传递、指针传递),在Lambda表达式中,外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。

值捕获

值捕获和参数传递中的值传递类似,被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入,因此随后对该变量的修改不会影响影响Lambda表达式中的值。

#include <iostream>


int main()
{
    int a = 98;

    auto f = [a]{ std::cout << a << std::endl; };

    a = 66;

    f(); // 输出98

    return 0;
}

这里需要注意的是,如果以传值方式捕获外部变量,则在Lambda表达式函数体中不能修改该外部变量的值

引用捕获

使用引用捕获一个外部变量,只需要在捕获列表变量前面加上一个引用说明符&

#include <iostream>

int main()
{
    int a = 98;

    auto f = [&a]{ std::cout << a << std::endl; };

    a = 66;

    f(); // 输出66

    return 0;
}

隐式捕获 

上面的值捕获和引用捕获都需要我们在捕获列表中显示列出Lambda表达式中使用的外部变量。除此之外,我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量,这种方式称之为隐式捕获。隐式捕获有两种方式,分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量,[&]表示以引用捕获的方式捕获外部变量。

 

#include <iostream>


int main()
{
    int a = 98;

    auto f = [=] () {std::cout << a << std::endl; };
    a = 66;
    f(); // 输出98

    return 0;
}
#include <iostream>


int main()
{
    int a = 98;

    auto f = [&] () {std::cout << a << std::endl; };
    a = 66;
    f(); // 输出66

    return 0;
}

混合捕获

要么是值捕获,要么是引用捕获,Lambda表达式还支持混合的方式捕获外部变量,这种方式主要是以上几种捕获方式的组合使用。

到这里,我们来总结一下:C++11中的Lambda表达式捕获外部变量主要有以下形式:

捕获形式说明
[] 不捕获任何外部变量
[变量名, …] 默认以值得形式捕获指定的多个外部变量(用逗号分隔),如果引用捕获,需要显示声明(使用&说明符)
[this] 以值的形式捕获this指针
[=] 以值的形式捕获所有外部变量
[&] 以引用形式捕获所有外部变量
[=, &x] 变量x以引用形式捕获,其余变量以传值形式捕获
[&, x] 变量x以值的形式捕获,其余变量以引用形式捕获

 

 

 

 

 

 

 

 

 

 

修改捕获变量

在Lambda表达式中,如果以传值方式捕获外部变量,则函数体中不能修改该外部变量,否则会引发编译错误。那么有没有办法可以修改值捕获的外部变量呢?这是就需要使用mutable关键字,该关键字用以说明表达式体内的代码可以修改值捕获的变量

#include <iostream>


int main()
{
    int a = 98;

    auto f = [=] () mutable { a = 15; std::cout << a << std::endl; };
    
    std::cout << a << std::endl; // 98

    f(); // 输出15

    std::cout << a << std::endl; // 98

    return 0;
}

综合例子

#include <iostream>
#include <functional>

int main()
{
    int m = [](int x) {
        return [](int y) {
            return y * 2;
        }(x)+6;
    }(5); 
    std::cout << m << std::endl; // 16

    std::cout << [](int x, int y) { return x+y; }(5,4) << std::endl; // 9

    auto g = [](int x)->std::function<int(int)> {
        return [=](int y) {
            return x + y;
        };
    };
    auto lf = g(4);
    std::cout << lf(5) << std::endl; // 9

    auto h = [](const std::function<int(int)> & f, int z) { return f(z)+1; };
    std::cout << h(g(7), 8) << std::endl; // 16


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


    return 0;
}

 

原文地址:https://www.cnblogs.com/zuofaqi/p/10191033.html