在现代 C++ 编程中，std::future 是处理异步操作结果的重要工具。它通常与 std::async 配合使用，能够以简洁的方式启动后台任务并安全地获取其返回值。以下通过多个代码实例展示如何结合 lambda 表达式、函数对象以及参数传递来实现高效的多线程异步计算。

使用 Lambda 执行延迟计算

lambda 表达式是定义轻量级可调用对象的理想选择。下面的例子演示了如何通过 std::async 在独立线程中运行一个延迟返回数值的 lambda：

#include <iostream>
#include <future>
#include <chrono>

int main() {
    auto task = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::milliseconds(800));
        return 123;
    });

    std::cout << "等待结果...\n";
    int outcome = task.get();
    std::cout << "接收到结果: " << outcome << '\n';

    return 0;
}

封装逻辑于函数对象

对于更复杂的业务逻辑，可以将行为封装在类中，并重载调用运算符。这种方式提高了代码的可读性和复用性：

#include <iostream>
#include <future>

class DataProcessor {
public:
    int operator()() const {
        // 模拟耗时处理
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return 999;
    }
};

int main() {
    DataProcessor worker;
    auto handle = std::async(std::launch::async, worker);

    std::cout << "正在处理数据...\n";
    int value = handle.get();
    std::cout << "处理完成，输出为: " << value << '\n';

    return 0;
}

Lambda 捕获局部变量进行异步运算

lambda 支持按值或引用捕获外部作用域中的变量。以下示例展示了如何将两个本地变量复制到异步上下文中执行乘法运算：

#include <iostream>
#include <future>

int main() {
    int base = 7;
    int multiplier = 6;

    auto computation = std::async(std::launch::async, [base, multiplier]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
        return base * multiplier;
    });

    std::cout << "计算 " << base << " × " << multiplier << " 的结果\n";
    int result = computation.get();
    std::cout << "结果: " << result << '\n';

    return 0;
}

向函数对象传递参数

除了无参调用，std::async 还支持向可调用实体传入额外参数。此特性适用于需要动态输入的任务：

#include <iostream>
#include <future>

struct SquareCalculator {
    int operator()(int x) const {
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
        return x * x;
    }
};

int main() {
    int num = 13;
    auto future_result = std::async(std::launch::async, SquareCalculator{}, num);

    std::cout << "计算 " << num << " 的平方...\n";
    int answer = future_result.get();
    std::cout << "答案: " << answer << '\n';

    return 0;
}

带状态的异步任务（Lambda 参数捕获）

当需要在异步任务中使用变化的输入时，可通过值捕获确保数据在线程间安全共享：

#include <iostream>
#include <future>

int main() {
    double amount = 25.5;
    double rate = 1.1;

    auto tax_task = std::async(std::launch::async, [amount, rate]() {
        return amount * rate;
    });

    std::cout << "含税金额: " << tax_task.get() << '\n';

    return 0;
}

这些示例体现了 std::future 和 std::async 在不同场景下的适应能力。无论是简单的闭包还是结构化的函数对象，都可以轻松集成进异步工作流中，提升程序并发性能的同时保持接口清晰。