std::promise和std::future用于線程間傳遞異步結(jié)果，promise通過set_value設(shè)置一次值，future通過get獲取結(jié)果并支持異常傳遞，適用于需精細(xì)控制結(jié)果設(shè)置的場景。

When you need to retrieve a result from an asynchronous operation in C , std::future and std::promise offer a clean way to pass values between threads. A std::promise lets you set a value (or exception) at some point, and a corresponding std::future allows you to retrieve that value later, potentially in another thread.

Understanding std::promise and std::future

A std::promise is a writable object that holds a value of type T (or an exception) which can be set once. You get a std::future from the promise using get_future(). This future acts as the reader side — it can wait for and retrieve the value.

Key points:

• Each promise is associated with exactly one future (or shared_future).
• The value is transferred only once — after setting it via set_value(), no further updates are allowed.
• If the future is accessed before the value is ready, it can block until available.

Basic usage with std::thread

You can use promise and future to return results from a thread manually:

#include <future><br>#include <thread><br>#include <iostream>
<p>void compute_and_set(std::promise<int>& prms) {
int result = 42; // Simulate some work
prms.set_value(result);
}</int></p>
<p>int main() {
std::promise<int> prm;
std::future<int> fut = prm.get_future();</int></int></p><pre class='brush:php;toolbar:false;'>std::thread t(compute_and_set, std::ref(prm));

std::cout << "Waiting for result...\n";
int value = fut.get(); // Blocks until value is ready
std::cout << "Got: " << value << "\n";

t.join();
return 0;

In this example, the thread computes a value and sets it through the promise. The main thread waits via fut.get().

Handling exceptions

A promise can also signal an error by calling set_exception():

void may_throw(std::promise<double>& prms) {
    try {
        throw std::runtime_error("Something went wrong");
    } catch (...) {
        prms.set_exception(std::current_exception());
    }
}

When fut.get() is called on the future, it will rethrow the captured exception.

Using std::async instead (simpler alternative)

In many cases, std::async is easier and more convenient. It automatically manages the promise/future pair:

auto fut = std::async([]() {
    return 7 * 6;
});
<p>std::cout << "Answer: " << fut.get() << "\n";</p>

This gives you a future directly without manually handling promises or threads.

Use std::promise when you need fine-grained control over when and where the result is set — such as in callbacks, custom thread pools, or event loops. Otherwise, std::async is often sufficient and cleaner.

Basically just match promise and future across communication boundaries, set once, get once, handle errors properly, and clean up threads.

以上是如何在 C 中使用 std::future 和 std::promise 實現(xiàn)異步結(jié)果的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！