C++新特性篇 - Lambada表达式

Lambda 表达式是现代 C++ 中最重要的特性之一,而 Lambda
表达式,实际上就是提供了一个类似匿名函数的特性,而匿名函数则是在需要一个函数,但是又不想费力去命名一个函数的情况下去使用的。这样的场景其实有很多很多,所以匿名函数几乎是现代编程语言的标配。

[捕获列表](参数列表) mutable(可选) 异常属性 -> 返回类型 {
// 函数体
}

捕获列表比较特殊,所谓捕获列表,其实可以理解为参数的一种类型,Lambda 表达式内部函数体在默认情况下是不能够使用函数体外部的变量的,这时候捕获列表可以起到传递外部数据的作用。有如下几种

  • [] 空捕获列表
  • [name1, name2, …] 捕获一系列变量
  • [&] 引用捕获, 让编译器自行推导引用列表
  • [=] 值捕获,让编译器自行推导值捕获列表
  • 表达式捕获,允许捕获的成员用任意的表达式进行初始化
#include<iostream>
#include<stack>
#include<vector>
#include <memory>  // std::make_unique
#include <utility> // std::move
void lambda_null_capture()
{
    std::cout << "lambda_null_capture\n";
    auto copy_value = [] {
        return 100;
    };
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
}
//值捕获测试
void lambda_value_capture() {
    std::cout << "lambda_value_capture\n";
    int value = 1;
    auto copy_value = [value] {
        return value;
    };
    value = 100;
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 这时, stored_value == 1, 而 value == 100.
    // 因为 copy_value 在创建时就保存了一份 value 的拷贝
}
//引用捕获测试
void lambda_reference_capture() {
    std::cout << "lambda_reference_capture\n";
    int value = 1;
    auto copy_value = [&value] {
        return value;
    };
    value = 100;
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 这时, stored_value == 100, value == 100.
    // 因为 copy_value 保存的是引用
}
//隐式捕获测试
void lambda_Implicit_capture() {
    std::cout << "lambda_Implicit_capture\n";
    int value = 1;
    auto copy_value = [=] {
        return value;
    };
    auto copy_value1 = [&] {
        return value;
    };
    value = 100;
    int stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 这时, stored_value == 1, 而 value == 100.
    // 因为 copy_value 在创建时就保存了一份 value 的拷贝
    stored_value = copy_value1();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 这时, stored_value == 100, value == 100.
    // 因为 copy_value1 保存的是引用
}
//C++14 给与了我们方便,允许捕获的成员用任意的表达式进行初始化,
//这就允许了右值的捕获, 被声明的捕获变量类型会根据表达式进行判断,判断方式与使用 auto 本质上是相同的
void lambda_expression_capture() {
    std::cout << "lambda_expression_capture\n";
    auto important = std::make_unique<int>(1);
    auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
        std::cout << "x = " << x << ",y = " << y << ",v1 = " << v1 << ",(*v2) = " << (*v2) << std::endl;
        return x + y + v1 + (*v2);//3+4+1+1=9
    };
    std::cout << add(3, 4) << std::endl;
}
//从 C++14 开始, Lambda 函数的形式参数可以使用 auto 关键字来产生意义上的泛型
void lambda_generic_paradigm()
{
    std::cout << "lambda_generic_paradigm\n";
    auto add = [](auto x, auto y) {
        return x + y;
    };

    std::cout << add(1, 2) << std::endl;
    std::cout << add(1.1, 2.2) << std::endl;
    
}
int main()
{
    lambda_null_capture();
    lambda_value_capture();
    lambda_reference_capture();
    lambda_Implicit_capture();
    lambda_expression_capture();
    lambda_generic_paradigm();
    return 0;
}

/*
lambda_null_capture
stored_value = 100
lambda_value_capture
stored_value = 1
lambda_reference_capture
stored_value = 100
lambda_Implicit_capture
stored_value = 1
stored_value = 100
lambda_expression_capture
x = 3,y = 4,v1 = 1,(*v2) = 1
9
lambda_generic_paradigm
3
3.3
*/
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值