C++lambda表达式捕获引用与值的区别

[=]

[x]

[&]

[&x]

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

void demonstrate_capture() {
    int value = 10;
    int& ref_value = value; // 只是为了展示引用捕获的危险性

    // 值捕获
    auto lambda_by_value = [value]() {
        // value在这里是原始value的一个副本
        std::cout << "Lambda by value: " << value << std::endl;
    };

    // 引用捕获
    auto lambda_by_reference = [&ref_value]() { // 注意这里捕获的是ref_value，它是一个引用
        // ref_value在这里直接指向原始的value
        std::cout << "Lambda by reference: " << ref_value << std::endl;
    };

    // 改变原始变量
    value = 20;

    // 调用lambda
    lambda_by_value();     // 输出 10 (捕获的是创建时的副本)
    lambda_by_reference(); // 输出 20 (捕获的是引用，看到了原始变量的变化)

    std::cout << "--------------------" << std::endl;

    // 悬空引用示例（模拟）
    std::function<void()> dangling_lambda;
    {
        int temp_var = 100;
        // 尝试捕获temp_var的引用
        dangling_lambda = [&temp_var]() {
            std::cout << "Dangling Lambda (might crash): " << temp_var << std::endl;
        };
        // temp_var 在这里作用域结束，被销毁
    } // temp_var is destroyed here!

    // 现在调用dangling_lambda，它持有的temp_var的引用已经无效了
    // 实际运行中这里很可能导致段错误或其他未定义行为
    // dangling_lambda(); // 强烈不建议运行这行代码，除非你知道你在做什么！

    // 正确的值捕获来避免悬空引用
    std::function<void()> safe_lambda;
    {
        int temp_var_safe = 200;
        safe_lambda = [temp_var_safe]() { // 按值捕获
            std::cout << "Safe Lambda (by value): " << temp_var_safe << std::endl;
        };
    } // temp_var_safe is destroyed here, but safe_lambda has its copy

    safe_lambda(); // 输出 200 (安全)

    // 异步场景下的值捕获安全性
    int async_data = 300;
    std::thread t([async_data]() { // 按值捕获
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟异步执行
        std::cout << "Async Lambda (by value): " << async_data << std::endl;
    });
    // async_data 在主线程中可能很快就失效了，但线程中的lambda有自己的副本
    t.detach(); // 分离线程，让它独立运行
}

// int main() {
//     demonstrate_capture();
//     // 等待异步线程完成，否则程序可能在线程输出前退出
//     std::this_thread::sleep_for(std::chrono::milliseconds(200));
//     return 0;
// }

#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <string>

void demonstrate_value_capture_scenarios() {
    // 场景1: 异步任务中避免悬空引用
    std::string user_name = "Alice";
    std::vector<int> data_vec = {1, 2, 3};

    // 使用值捕获，确保线程有自己的副本
    auto process_user_data = [user_name, data_vec]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟耗时操作
        std::cout << "Processing user: " << user_name << ", data size: " << data_vec.size() << std::endl;
    };

    std::thread t(process_user_data);
    // user_name 和 data_vec 在主线程中可能很快就会超出作用域
    // 但t中的lambda拥有它们的副本，是安全的
    t.detach(); // 分离线程，让它独立运行

    // 场景2: 捕获变量的“快照”
    int counter = 0;
    std::vector<std::function<void()>> snapshots;

    for (int i = 0; i < 3; ++i) {
        counter++;
        // 每次循环都捕获counter的当前值
        snapshots.push_back([current_counter = counter]() { // C++14广义捕获也可以看作值捕获的一种
            std::cout << "Snapshot counter: " << current_counter << std::endl;
        });
    }
    counter = 100; // 改变原始counter

    std::cout << "--- Snapshots ---" << std::endl;
    for (const auto& snap : snapshots) {
        snap(); // 输出 1, 2, 3，而不是100
    }

    // 场景3: 使用mutable修改副本
    int mutable_val = 5;
    auto increment_and_print = [mutable_val]() mutable { // mutable 允许修改捕获的副本
        std::cout << "Before increment: " << mutable_val << std::endl;
        mutable_val++; // 修改的是副本
        std::cout << "After increment: " << mutable_val << std::endl;
    };

    increment_and_print(); // 输出 5, 6
    increment_and_print(); // 输出 6, 7 (每次调用都会在副本上继续修改)
    std::cout << "Original mutable_val: " << mutable_val << std::endl; // 仍然是 5

    // 等待异步线程完成
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

// int main() {
//     demonstrate_value_capture_scenarios();
//     return 0;
// }

#include <iostream>
#include <functional>
#include <thread>
#include <chrono>
#include <memory> // For std::shared_ptr

void run_lambda(std::function<void()> f) {
    f();
}

void demonstrate_reference_capture_risks() {
    // 风险1: 局部变量的悬空引用
    std::function<void()> dangling_lambda_func;
    {
        int local_data = 42;
        // 警告：这里捕获了local_data的引用
        dangling_lambda_func = [&local_data]() {
            std::cout << "Dangling reference access (might crash): " << local_data << std::endl;
        };
        // local_data 在这里超出作用域并被销毁
    } // local_data is gone!

    std::cout << "Attempting to call dangling_lambda_func..." << std::endl;
    // 极有可能导致未定义行为或崩溃
    // dangling_lambda_func(); // ！！！ DO NOT UNCOMMENT IN PRODUCTION CODE ！！！

    // 最佳实践1: 值捕获避免悬空引用
    std::function<void()> safe_lambda_func;
    {
        int local_data_safe = 100;
        safe_lambda_func = [local_data_safe]() { // 按值捕获
            std::cout << "Safe value capture: " << local_data_safe << std::endl;
        };
    } // local_data_safe is gone, but safe_lambda_func has a copy
    safe_lambda_func(); // 安全，输出 100

    // 风险2: 异步线程中的悬空引用
    int thread_data = 200;
    std::thread t_bad([&thread_data]() { // 警告：按引用捕获
        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // 模拟延迟
        // 如果主线程在此时退出，thread_data可能已销毁
        std::cout << "Thread lambda (risky reference): " << thread_data << std::endl;
    });
    // thread_data 在这里可能很快被销毁，但t_bad可能还没执行
    // t_bad.join(); // 如果不join，主线程退出时thread_data可能已销毁
    t_bad.detach(); // 更危险，主线程可能不等它

    // 最佳实践2: 异步线程中使用值捕获
    int thread_data_safe = 300;
    std::thread t_good([thread_data_safe]() { // 按值捕获
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
        std::cout << "Thread lambda (safe value): " << thread_data_safe << std::endl;
    });
    t_good.detach();

    // 最佳实践3: 使用std::shared_ptr管理共享对象生命周期
    auto shared_int = std::make_shared<int>(400);
    std::thread t_shared([shared_int]() { // 捕获shared_ptr的副本，延长对象生命周期
        std::this_thread::sleep_for(std::chrono::milliseconds(30));
        std::cout << "Shared_ptr lambda: " << *shared_int << std::endl;
    });
    t_shared.detach();

    // 确保异步操作有时间完成
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

// int main() {
//     demonstrate_reference_capture_risks();
//     return 0;
// }