Soddisfare una promessa (possibilmente nulla)

Question

Sto scrivendo del codice multithreaded e utilizzo di promise/future per chiamare una funzione su un thread diverso e restituirne il risultato. Per simplicitly, mi tolgo la parte filettatura del tutto:

template <typename F> 
auto blockingCall(F f) -> decltype(f()) 
{ 
    std::promise<decltype(f())> promise; 

    // fulfill the promise 
    promise.set_value(f()); 

    // block until we have a result 
    return promise.get_future().get(); 
} 

Questa grande opera per qualsiasi funzione che restituisce non void. E la dichiarazione di ritorno per il futuro funziona anche per void. Ma non posso mantenere la promessa, se f è una funzione di void, perché:

promise.set_value (f()); // errore: utilizzo non valido di espressione vuoto

C'è un modo intelligente di impostare il valore nel caso void in linea, o devo scrivere solo una funzione di supporto come call_set_value(promise, f) che ha un overload per std::promise<R> e std::promise<void>?

Answer 1

Un promise è solo un tipo di erogatori risultato asincrono. Invece di un promise si potrebbe usare un packaged_task che avvolge un oggetto callable, simile ad un std::function tranne che invoca rende i risultati disponibili attraverso un future (e, naturalmente, gestisce la differenza tra void ed i risultati non nullo):

template <typename F> 
auto blockingCall(F f) -> decltype(f()) 
{ 
    std::packaged_task<decltype(f())()> task(std::move(f)); 

    task(); 

    // block until we have a result 
    return task.get_future().get(); 
} 

NB in base allo standard corrente, questo codice avrebbe una corsa di dati se task() e task.get_future() si verificano su thread separati (e quindi il tuo originale usando una promessa), quindi dovresti chiamare get_future() prima di passare l'attività all'altro thread. In pratica dovrebbe essere sicuro sulle implementazioni reali e c'è un problema di libreria (LWG 2412) per renderlo comunque valido.

Answer 2

Sì. sovraccarico funzione è la soluzione più pulita:

set(promise, f); 

poi attuare set come funzioni sovraccaricate, come:

template<typename F, typename R> 
void set(std::promise<R> & p, F && f) //handle non-void here 
{ 
    p.set_value(f()); 
} 

template<typename F> 
void set(std::promise<void> & p, F && f) //handle void here 
{ 
    f(); 
    p.set_value(); 
}