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
*/