C++多线程异步编程std::future的进一步例子

std::future不仅可以用于异步任务的结果传递，还可以与函数对象或lambda表达式结合使用，以便在异步线程中执行这些任务。下面是一些示例，展示了如何将函数对象和lambda表达式传递给std::future。

示例1: 使用lambda表达式

#include <iostream>
#include <future>

int main() {
    // 创建一个异步任务，使用lambda表达式
    auto fut = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return 42;
    });

    // 等待并获取结果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

示例2: 使用函数对象

#include <iostream>
#include <future>
#include <thread>

// 定义一个函数对象
struct ComputeResult {
    int operator()() const {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return 42;
    }
};

int main() {
    // 创建一个异步任务，使用函数对象
    auto fut = std::async(std::launch::async, ComputeResult{});

    // 等待并获取结果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

示例3: 传递带有参数的lambda表达式

#include <iostream>
#include <future>
#include <thread>

int main() {
    // 创建一个异步任务，使用带有参数的lambda表达式
    int input = 10;
    auto fut = std::async(std::launch::async, [input] {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return input * 2;
    });

    // 等待并获取结果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

示例4: 传递带参数的函数对象

#include <iostream>
#include <future>
#include <thread>

// 定义一个带有参数的函数对象
struct ComputeResultWithParam {
    int operator()(int input) const {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return input * 2;
    }
};

int main() {
    // 创建一个异步任务，使用带有参数的函数对象
    int input = 10;
    ComputeResultWithParam compute;
    auto fut = std::async(std::launch::async, compute, input);

    // 等待并获取结果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

示例5: 传递捕获外部变量的lambda表达式

#include <iostream>
#include <future>
#include <thread>

int main() {
    int input = 10;
    int factor = 2;

    // 创建一个异步任务，使用捕获外部变量的lambda表达式
    auto fut = std::async(std::launch::async, [input, factor] {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return input * factor;
    });

    // 等待并获取结果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

总结

通过这些示例，你可以看到std::future可以非常灵活地与函数对象和lambda表达式结合使用，从而在异步任务中执行复杂的计算。std::async函数的使用使得创建和管理这些异步任务变得非常简单。希望这些示例能帮助你更好地理解和使用std::future和std::async。