Futures and Promises

In C++, std::promise and std::future provide a unidirectional channel to pass values, exceptions, or signals from a producer thread to a consumer thread.

The Single-Use Rule of Futures

A standard std::future is single-use. When you call get(), it blocks until the value is ready, moves the value out of the shared state, and invalidates the future.

Code Walkthrough

Demonstrates passing values and forwarding runtime exceptions across thread boundaries.

#include <iostream>
#include <future>
#include <thread>
#include <stdexcept>
void worker(std::promise<int> promiseObj) {
    try {
        // Perform calculations
        int result = 42;
        promiseObj.set_value(result); // Pass value to consumer
    } catch (...) {
        // Capture exception and pass it to the consumer
        promiseObj.set_exception(std::current_exception());
    }
}
int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
std::thread t(worker, std::move(prom)); // Move promise into thread
try {
        int val = fut.get(); // Blocks until value is ready
        std::cout << "Received Value: " << val << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Exception from worker thread: " << e.what() << std::endl;
    }
t.join();
    return 0;
}

Interview-Relevant Information