Lambda表达式

Lambda表达式

Lambda表达式基础介绍

1. 结构

[capture](parameters) -> return_type { body }

2. 组成部分介绍

• 捕获列表：
  • 按值捕获：[x, y]或者[=]（捕获作用域外的所有变量）
  • 按引用捕获：[&x, &y]或者[&]（捕获作用域外的所有变量的引用）
  • 混合捕获：[x, &y]（按值捕获x，按引用捕获y）
  • 捕获this指针：[this](按值捕获this指针，函数体具有该对象的所有访问权限）

[=]和[&]捕获的是作用域外的所有变量（引用），这里的作用域外指的是两部分：

1. 定义Lambda表达式的函数
2. 定义Lambda表达式的函数所在的类

所以，以[=]和[&]方式捕获时，可以访问该类的所有接口和数据。

• 参数列表：
  • 与普通函数参数类似，可以是无参或有参
• 返回类型：
  • 使用-> return_type指定
  • 可以省略，由编译器推导
• 函数体：
  • 包含要执行的实际代码
    

Lambda的扩展使用

1. **mutable**关键字

Lambda表达式在按值捕获时，捕获的参数有const修饰，函数体内无法修改参数。
使用mutable关键字，允许修改按值捕获的变量：

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [=](int y) mutable -> int {
        x += y;
        return x;
    };
    std::cout << lambda(5) << std::endl; // Output: 15
    return 0;
}

2. 
   

模拟Lambda生成的匿名类

#include <iostream>

void example() {
    int x = 42;
    auto lambda_by_value = [x](int y) { return x + y; };
    auto lambda_by_ref = [&x](int y) { return x + y; };

    / 模拟编译器生成的匿名类 
    // 值捕获
    class __lambda_by_value {
    private:
        int x; // 捕获的变量（值）

    public:
        __lambda_by_value(int _x) : x(_x) {}

        int operator()(int y) const {
            return x + y;
        }
    };

    // 引用捕获
    class __lambda_by_ref {
    private:
        int& x; // 捕获的变量（引用）

    public:
        __lambda_by_ref(int& _x) : x(_x) {}

        int operator()(int y) const {
            return x + y;
        }
    };

    // 创建匿名对象
    __lambda_by_value lambda_obj_value(x);
    __lambda_by_ref lambda_obj_ref(x);
    /
}

int main() {
    example();
    return 0;
}

在类成员函数定义Lambda表达式，并捕获this指针时，实现会有些区别：

#include <iostream>

class MyClass {
private:
    int memberVar = 20;

public:
    void example() {
        int localVar = 10;

        // Lambda表达式捕获this和localVar
        auto lambda = [this, localVar]() {
            std::cout << "Inside Lambda - Member Variable: " << memberVar << "\n";
            std::cout << "Inside Lambda - Local Variable (captured by value): " << localVar << "\n";
            memberVar += 5; // 可以修改成员变量
        };

        // 模拟编译器生成的闭包类
        class __lambda {
        private:
            MyClass* _this;  // 捕获的this指针
            int localVar;    // 捕获的局部变量（值）

        public:
            // 构造函数初始化捕获的this指针和局部变量
            __lambda(MyClass* this_ptr, int local_var) : _this(this_ptr), localVar(local_var) {}

            void operator()() const {
                std::cout << "Inside Lambda - Member Variable: " << _this->memberVar << "\n";
                std::cout << "Inside Lambda - Local Variable (captured by value): " << localVar << "\n";
                _this->memberVar += 5; // 修改成员变量
            }
        };

        // 创建闭包对象
        __lambda lambda_obj(this, localVar);
        lambda_obj();
    }
};

int main() {
    MyClass obj;
    obj.example();
    return 0;
}

Lambda从C++11~20的变化

1. C++11

Lambda表达式是在C++11版本正式推出，具备较为完善的基础功能：

• 捕获列表
• 参数列表
• mutable关键字

2. C++14

C++14主要新增功能：

• 通用捕获：
  • 支持移动捕获（std::move）和通过初始化捕获变量。
• 返回类型推导：
  • Lambda表达式可以自动推导返回类型，不需要显示指定。

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto lambda = [vec = std::move(vec)]() {
        for (int i : vec) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    };
    lambda(); // Output: 1 2 3 4 5
    return 0;
}

3. C++17

C++17主要新增功能：

• this捕获的改进：
  • 允许[=*this]捕获当前对象的副本
• Lambda表达式的constexpr支持：
  • Lambda表达式可以是constexpr，使其在编译时求值。

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [=]() constexpr {
        return x * 2;
    };
    constexpr int result = lambda();
    std::cout << result << std::endl; // Output: 20
    return 0;
}

4. C++20

C++20主要新增功能：

• 模板Lambda：
  • 支持Lambda表达式模板参数，允许定义泛型Lambda
• constexprLambda增强：
  • constexprLambda可以在constexpr上下文中更广泛地使用
• 默认可复制捕获：
  • 支持捕获的变量默认可复制和可移动，简化了Lambda的使用

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

int main() {
    auto lambda = []<typename T>(T x) {
        return x + x;
    };
    std::cout << lambda(10) << std::endl; // Output: 20
    std::cout << lambda(10.5) << std::endl; // Output: 21.0

    // 使用捕获的变量的副本
    int value = 10;
    auto lambda_copy = [val = value]() {
        return val + 1;
    };
    std::cout << lambda_copy() << std::endl; // Output: 11

    return 0;
}

内存存储位置

Lambda表达式的存储位置主要取决于它们的闭包对象（closure object）和捕获变量的类型。Lambda表达式在编译时被转化为一个闭包类（closure class），这个类的实例就是闭包对象。

1. 无捕获的Lambda表达式：

• 存储位置：通常是代码区
• 原因：无捕获的Lambda表达式类似于普通函数，不包含任何状态信息，只包含代码。

2. 有捕获的Lambda表达式：

• 存储位置：
  • 栈：如果Lambda表达式定义在函数内且捕获变量是局部变量，闭包对象通常存储在栈上。
  • 堆：如果通过std::function等方式动态分配Lambda表达式，闭包对象可能存储在堆上。
    

Lambda使用场景注意事项

1. Lambda作为线程函数，并引用捕获了局部变量/成员变量（生命周期未知）

#include <iostream>
#include <thread>
#include <chrono>

std::thread example() {
    int localVar = 42;

    // 定义Lambda表达式并值捕获局部变量
    auto lambda = [&localVar]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "Captured localVar: " << localVar << "\n";
    };

    // 启动线程并传递Lambda表达式
    return std::thread(lambda);
}

int main() {
    auto t = example();
    t.join();
    return 0;
}

注意：Lambda引用捕获了局部变量localVar，那么在example()结束时，localVar变量就被销毁了，但线程函数（Lambda表达式）没有结束，如果访问localVar变量会导致未定义的行为。

解决方案：

1. 引用捕获改为值捕获
2. 值捕获一个共享指针对象