掌握现代 C++:Lambda 在 C++14、C++17 和 C++20 中的演变

一、背景

Lambda 是现代 C++ 最受欢迎的功能之一。自从在 C++ 11 中引入以来,它们在 C++ 代码中无处不在。而且,自从它们在 C++11 中出现以来,它们已经发展并获得了重要的功能。其中一些功能有助于编写更具表现力的代码,并且由于现在使用 lambda 非常普遍,因此花时间学习可以用它们做什么是非常值得的。

本文目标是剖析 lambda 的主要演变过程,但不是所有的小细节。对 lambda 的基础知识不了解可以阅读博主的另一篇文章,有详细介绍。

lambda 的一般演变是赋予它们手动定义的函数对象的功能。
在这里插入图片描述

二、C++14 中的 Lambda

在 C++14 中,lambda 获得了 4 项主要增强功能:

  • 默认参数
  • 模板参数
  • 广义捕获
  • 从函数返回 lambda

2.1、默认参数

在 C++14 中,lambda 可以采用默认参数,就像任何函数一样:

auto myLambda = [](int x, int y = 0) { 
    std::cout << x << '-' << y << '\n'; 
};

std::cout << myLambda(1, 2) << '\n';
std::cout << myLambda(1) << '\n';

输出:

1-2
1-0

2.2、模板参数

在 C++11 中必须定义 lambda 参数的类型:

auto myLambda = [](int x){ 
    std::cout << x << '\n'; 
};

在 C++14 中,可以让它们接受任何类型:

auto myLambda = [](auto&& x){ 
    std::cout << x << '\n'; 
};

即使不需要处理多种类型,这对于避免重复并使代码更紧凑和可读也很有用。例如,这种 lambda:

auto myLambda = [](namespace1::namespace2::namespace3::ACertainTypeOfWidget const& widget) { 
    std::cout << widget.value() << '\n'; 
};

变成:

auto myLambda = [](auto&& widget) { 
    std::cout << widget.value() << '\n'; 
};

2.3、广义捕获

在 C++11 中,lambda 只能捕获其作用域中的现有对象:

int z = 42;
auto myLambda = [z](int x){ 
    std::cout << x << '-' << z + 2 << '\n'; 
};

C++14 借助强大的lambda广义捕获,可以用几乎任何东西初始化捕获的值。示例:

int z = 42;
auto myLambda = [y = z + 2](int x) { 
    std::cout << x << '-' << y << '\n'; 
};

myLambda(1);

此代码输出以下内容:

1-44

2.4、从函数返回 lambda

Lambda 受益于 C++14 的语言功能:从函数返回,而无需指定返回类型。由于 lambda 的类型是由编译器生成的,因此在 C++11 中无法从函数返回 lambda。

/* what type should we write here ?? */ 
f()
{
    return [](int x){ return x * 2; };
}

在 C++14 中可以通过用作返回类型来返回 lambda。这在一段代码中间有一个大的 lambda 的情况下很有用。

void f()
{
    // ...
    int z = 42;
    auto myLambda = [z](int x) {
        // ...
        // ...
        // ...
    };
    // ...
}

可以将 lambda 打包到另一个函数中,从而引入另一个抽象级别:

auto getMyLambda(int z)
{
    return [z](int x) {
        // ...
        // ...
        // ...
    };
}

void f()
{
    // ...
    int z = 42;
    auto myLambda = getMyLambda(z);
    // ...
}

三、C++17 中的 Lambda

C++17 为 lambda 带来了一个重大增强:它们可以声明constexpr

constexpr auto times2 = [] (int n) { 
    return n * 2; 
};

然后,可以在编译时评估的上下文中使用此类 lambda:

static_assert(times2(3) == 6);

这在模板编程中特别有用。

注意:lambda 在 C++20 中变得更加有用。事实上,只有在 C++20 中,大多数 STL 算法才变得如此,并且它们可以与 lambda 一起使用,以创建在编译时评估的集合的复杂操作。
不过,有一个例外:std::array非变异访问操作在 C++ 14 中立即变为std::array constexpr,而在 C++17 中变为非变异访问操作constexpr

捕获 *this 的副本:lambda 在 C++17 中获得的另一个特性是捕获*this的副本的简单语法。
示例:

struct MyType{
    int m_value;
    auto getLambda()  {
        return [this](){ return m_value; };
    }
};

此 lambda 捕获this指针的副本。如果 lambda 的生存期超过对象的生存期,则可能会导致内存错误,例如:

auto lambda = MyType{42}.getLambda();
lambda();

由于MyType在第一个语句的末尾被销毁,因此第二个语句调用的lambda取消了this引用访问其m_value ,但this指向一个被销毁的对象。这会导致未定义的行为,通常是应用程序崩溃。

解决此问题是在 lambda 中捕获整个*this对象的副本。C++17 提供了语法来实现这一点。

struct MyType
{
    int m_value;
    auto getLambda() {
        return [*this](){ return m_value; };
    }
};

当然,在 C++ 14 中使用广义捕获已经可以实现相同的结果:

struct MyType
{
    int m_value;
    auto getLambda() {
        return [self = *this](){ return self.m_value; };
    }
};

只是C++17 使语法更好。

四、C++20 中的 Lambda

Lambda 在 C++ 20 中得到进一步发展,但其功能不如 C++ 或 C++ 17 那么基本。C++ 20 中 lambda 的一个增强功能是定义模板的经典语法,使它们更接近手动定义的函数对象:

auto myLambda = []<typename T>(T&& value){ std::cout << value << '\n'; };

这使得访问模板参数类型比使用 表达式(如auto&&)的 C++ lambda 模板更容易。

另一个改进是能够捕获可变参数包:

template<typename... Ts>
void f(Ts&&... args)
{
    auto myLambda = [...args = std::forward<Ts>(args)](){};
}

总结

本文讨论了lambda从C++14到C++20的主要改进。但也还有更多没有总结进来。这些主要功能伴随着许多小特性使 lambda 代码更易于编写。

深入研究 lambda 是更好地了解 C++ 语言的绝佳机会,这是一个值得投入的时间。

C++14
C++17
C++20
Auto return type deduction
Initializing captured variables
Generic Lambdas
Init-capture
Fold expressions
if constexpr in Lambdas
Capture initialization expression
= for capturing all variables
Consteval Lambdas

在这里插入图片描述

  • 39
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
Lambda表达式是C++11引入的一种函数对象,可以在需要函数对象的地方使用,比如作为函数参数、返回值等。Lambda表达式的语法形式如下: ``` [capture list](parameters) mutable exception -> return type { // function body } ``` 其,`capture list` 表示捕获列表,用于捕获外部变量。`parameters` 表示函数参数列表,`mutable` 用于表示是否可以修改值传递的变量,`exception` 是异常列表,`return type` 表示返回类型,`function body` 则是函数体。 在Lambda表达式,可以通过 `[this]` 捕获当前对象的指针,即 `this` 指针,可以方便地访问当前对象的成员变量和成员函数。例如: ``` class MyClass { public: void foo() { int x = 1; auto lambda = [this, x]() mutable { this->m_member_var += x; this->m_member_function(); x++; }; lambda(); } private: int m_member_var; void m_member_function(); }; ``` 在上面的例子Lambda表达式通过 `[this, x]` 捕获了当前对象的指针和 `foo()` 函数定义的变量 `x`。在 Lambda 表达式可以通过 `this->m_member_var` 和 `this->m_member_function()` 访问当前对象的成员变量和成员函数。由于 `x` 是值传递的,所以在 Lambda 表达式需要使用 `mutable` 关键字使其可修改,可以通过 `x++` 修改变量的值。最后调用 `lambda()` 执行 Lambda 表达式。 需要注意的是,Lambda表达式捕获 `this` 指针时,需要保证当前对象是有效的,即不能在已经销毁的对象访问成员变量和成员函数。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lion Long

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值