Is a future safe to pass to a detached thread?

Question

Is passing a std::future to a detached instance of std::thread a safe operation? I know that underneath, the std::future has state in a shared_ptr which it shares with a std::promise. Here is an example.

int main()
{
    std::promise<void> p;
    std::thread( [f = p.get_future()]() {
        if ( f.wait_for( std::chrono::seconds( 2 ) ) == std::future_status::ready ) 
        {
            return;
        }

        std::terminate();
    } ).detach();

    // wait for some operation

    p.set_value();
}

There is a potential error case in the above code where the lambda is executed after the main thread exits. Does the shared state remain after the main thread exits?

Answer 1

[basic.start.term]/6 If there is a use of a standard library object or function not permitted within signal handlers (21.10) that does not happen before (4.7) completion of destruction of objects with static storage duration and execution of std::atexit registered functions (21.5), the program has undefined behavior.

Per [basic.start.main]/5, returning from main has the effect of calling std::exit, which does destroy objects with static storage duration and execute std::atexit registered functions. Therefore, I believe your example exhibits undefined behavior.