c++ lambda

Lambda

Lambda 表达式一般用于定义匿名函数,使得代码更加灵活简洁,优点:

  1. 声明式编程风格:就地匿名定义目标函数或函数对象,不需要额外写一个命名函数或者函数对象。以更直接的方式去写程序,好的可读性和可维护性。
  2. 简洁:不需要额外再写一个函数或者函数对象,避免了代码膨胀和功能分散,让开发者更加集中精力在手边的问题,同时也获取了更高的生产率。
  3. 在需要的时间和地点实现功能闭包,使程序更灵活。

Lambda表达式具体形式:

auto func = [capture] (params) opt -> ret { func_body; };
  • func:Lambda 表达式的名字,作为一个函数使用;
  • capture:捕获列表;
  • params:参数列表,如果没有参数,圆括号()可以省略;
  • opt:函数选项(mutable, noexcept之类);
  • ret:返回值类型,可以不写,让编译器根据返回值自动推导;
  • func_body:函数体。

capture取值:

  • [] //未定义变量.试图在Lambda内使用任何外部变量都是错误的
  • [x, &y] //x 按值捕获, y 按引用捕获.
  • [&] //用到的任何外部变量都隐式按引用捕获
  • [=] //用到的任何外部变量都隐式按值捕获
  • [&, x] //x显式地按值捕获. 其它变量按引用捕获
  • [=, &z] //z按引用捕获. 其它变量按值捕获
  • [this]:通过引用捕获当前对象(其实是复制指针)
  • [*this]:通过传值方式捕获当前对象;

捕获本地变量

空的[](Lambda introducer)就不能引用当前范围内的本地变量,只能使用全局变量,或将其他值以参数的形式进行传递。
想要访问一个本地变量,需要对其进行捕获。最简单的方式就是将范围内的所有本地变量都进行捕获,使用[=]就可以。

int a = 0, b = 1;
auto f1 = []{ return a; };               // 错误,没有捕获外部变量
auto f2 = [=]{ return a + b; };          // 正确,捕获所有外部变量,并返回a + b
auto f3 = [=]{ return a++; };            // 错误,a是以复制方式捕获的,无法修改

示例

#include <iostream>
#include <functional>

int main() {
    int i = 111, j = 222, k = 333;
    auto f = [&i, j, k] { return i + j + k; }; 
    i = 1;
    j = 2;
    k = 3;
    std::cout << f() << std::endl;
}

内部原理

编译器为每个Lambda表达式生成唯一闭包。捕获列表将成为闭包中的构造函数的参数,如果将参数按值捕获,那么相应类型的数据成员将在闭包中创建。此外,可以在Lambda表达式的参数中声明变量/对象,它们将成为调用operator()函数的参数。

  • 值捕获
int x = 1; int y = 2;
auto plus = [=] (int a, int b) -> int { return x + y + a + b; };
int c = plus(1, 2);

编译器将翻译为

class LambdaClass {
public:
    LambdaClass(int x, int y)
    : x_(x), y_(y) {}

    int operator () (int a, int b) const {
        return x_ + y_ + a + b;
    }

private:
    int x_;
    int y_;
}

int x = 1; int y = 2;
LambdaClass plus(x, y);
int c = plus(1, 2);
  • 引用捕获
int x = 1; int y = 2;
auto plus = [&] (int a, int b) -> int { x++; return x + y + a + b;};
int c = plus(1, 2);

编译器将翻译为

class LambdaClass {
public:
    LambdaClass(int& x, int& y)
    : x_(x), y_(y) {}

    int operator () (int a, int b) {
        x_++;
        return x_ + y_ + a + b;
    }

private:
    int &x_;
    int &y_;
};

引用捕获变量,和值捕获的方式有3个不同的地方:

  1. 参数引用的方式进行传递;
  2. 引用捕获在函数体修改变量,会直接修改lambda表达式外部的变量;
  3. opeartor()函数不是const的。

lambda的各个成分和类的各个成分对应起来就是如下的关系:

  • 捕获列表,对应LambdaClass类的private成员。
  • 参数列表,对应LambdaClass类的成员函数的operator()的形参列表
  • mutable,对应 LambdaClass类成员函数 operator() 的const属性 ,但是只有在捕获列表捕获的参数不含有引用捕获的情况下才会生效,因为捕获列表只要包含引用捕获,那operator()函数就一定是非const函数。
  • 返回类型,对应 LambdaClass类成员函数 operator() 的返回类型
  • 函数体,对应 LambdaClass类成员函数 operator() 的函数体。
  • 引用捕获和值捕获不同的一点就是,对应的成员是否为引用类型。

Mutable Lambda表达式

Lambda函数的call-operator(调用运算符)隐式为const-by-value(常量,按值捕获),这意味着它是不可变的。 但是函数内部想修改这变量,但是又不想影响lambda表达式外面的值的时候,就直接添加mutable属性,这样调用lambda表达式的时候,会像函数传递参数一样,在内部定义一个变量并拷贝这个值。

#include <iostream>
using namespace std;

int main()
{
	int t = 9;
	auto f = [t] () mutable {return ++t; };
	cout << f() << endl;
	cout << f() << endl;
	cout << "t:" << t << endl;
	return 0;
}

在这里插入图片描述
捕获的变量t,它在刚开始被捕获的初始值是9,调用一次f之后,变成了10,再调用一次,就变成了11。 但是最终的输出t,也就是main()函数里面定义的t,由于是值捕获,所以它的值一直不会变,最终还将输出9。

Lambda 表达式的类型

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

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

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

using func_t = int(*)(int);
func_t f1 = [](int a){ return a; };  // 正确,没有捕获的的lambda表达式可以直接转换为函数指针
f1(123);
func_t f2 = [&](int a){ return a; };  // 错误,有捕获的lambda表达式不能直接转换为函数指针

lambda 表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量,最终均会变为闭包类型的成员变量。而一个使用了成员变量的类的 operator(),如果能直接被转换为普通的函数指针,那么 lambda 表达式本身的 this 指针就丢失掉了。而没有捕获任何外部变量的 lambda 表达式则不存在这个问题。这里也可以很自然地解释为何按值捕获无法修改捕获的外部变量。因为按照 C++ 标准,lambda 表达式的 operator() 默认是 const 的。一个 const 成员函数是无法修改成员变量的值的。而 mutable 的作用,就在于取消 operator() 的 const。

Lambda auto参数

在C++ 14中引入的泛型Lambda,它可以使用auto标识符捕获参数。参数声明为auto是借助了模板的推断机制

auto func = [] (auto x, auto y) {
    return x + y;
};
// 上述的lambda相当于如下类的对象
class X {
public:
    template<typename T1, typename T2>
    auto operator() (T1 x, T2 y) const { // auto借助了T1和T2的推断
        return x + y;
    }
};

func(1, 2);
// 等价于
X{}(1, 2);

constexpr Lambda表达式

C++17前lambda表达式只能在运行时使用,C++17引入了constexpr lambda表达式,可以用于在编译期进行计算。
constexpr lambda 表达式有如下限制:函数体不能包含汇编语句、goto语句、label、try块、静态变量、线程局部存储、没有初始化的普通变量,不能动态分配内存,不能有new delete等,不能虚函数。

#include <iostream>
#include <functional>

int main() {
    constexpr auto lamb = [] (int n) { return n * n; };
    static_assert(lamb(3) != 9, "a");
}

也可将 lambda 表达式声明为常量表达式或在常量表达式中使用

#include <iostream>
#include <string>

constexpr int Increment(int n) {
    auto add1 = [n]()    //Callable named lambda
    {
        return n + 1;
    };
    return add1();  //call it
}

int main() {
    constexpr int number3 = Increment(2);
    std::cout << number3 << std::endl;
}

this拷贝

C++17中,可在lambda表达式的捕获类别里[]写上*this,表示传递到lambda中的是this对象的拷贝。
lambda中的[*this]就是一个对象的拷贝,这意味着传递了d的一个拷贝。因此,线程在调用d的析构函数后使用传递的对象是没有问题的。
如果用[this]、[=]或[&]捕获了,那么线程将运行未定义的行为,因为在传递给线程的lambda中打印name时,lambda将使用已销毁对象的成员。

#include <iostream>
#include <string>
#include <thread>
 
class Data {
private:
	std::string name;
public:
	Data(const std::string& s) : name(s) {
	}

	std::thread startThreadWithCopyOfThis() const 
    {
	    // start and return new thread using this after 3 seconds:
	    std::thread t([*this]
        {
	        std::cout << "I will shellp 3 seconds" << std::endl;
            std::this_thread::sleep_for(std::chrono::seconds(3));
            std::cout << name << std::endl;
	    });
	    return t;
	}
};

int main()
{
	std::thread t;
	{
	    Data d{ "This copy capture in C++17" };
	    t = d.startThreadWithCopyOfThis();
	} // d已经销毁
	std::cout << "the main thread wait for sub thread end." << std::endl;
	t.join();
	return 0;
}
  • 2
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值