può uno std :: promettere da un oggetto non POD?

Question

Una delle cose che fa la mia app è ascoltare e ricevere i carichi utili da un socket. Non voglio mai bloccare. Su ogni payload ricevuto, voglio creare un oggetto e passarlo a un thread di lavoro e dimenticarlo fino a più tardi, ovvero come funziona il codice prototipo. Ma per il codice di produzione voglio ridurre la complessità (la mia app è grande) usando il comodo metodo asincrono. async prende un futuro fatto da una promessa. Per farlo funzionare ho bisogno di creare una promessa sul mio oggetto non POD rappresentato di seguito dalla classe Xxx. Non vedo alcun modo per farlo (vedi errore nel mio codice di esempio qui sotto). È appropriato usare async qui? Se sì, come posso costruire un/oggetto futura promessa che è più complessa di int (tutti gli esempi di codice ho vedono sia per uso int o void):

#include <future> 
class Xxx //non-POD object 
{ 
    int i; 
public: 
    Xxx(int i) : i(i) {} 
    int GetSquare() { return i * i; } 
}; 

int factorial(std::future<Xxx> f) 
{ 
    int res = 1; 
    auto xxx = f.get(); 
    for(int i = xxx.GetSquare(); i > 1; i--) 
    { 
    res *= i; 
    } 
    return res; 
} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    Xxx xxx(2); // 2 represents one payload from the socket 
    std::promise<Xxx> p; // error: no appropriate default constructor available 
    std::future<Xxx> f = p.get_future(); 
    std::future<int> fu = std::async(factorial, std::move(f)); 
    p.set_value(xxx); 
    fu.wait(); 
    return 0; 
} 

Answer 1

Come già detto Mike, è sicuramente un bug nell'implementazione di Visual C++ di std::promise, quello che stai facendo dovrebbe funzionare.

Ma sono curioso perché lo devi fare comunque. Forse c'è qualche altro requisito che non hai dimostrato di mantenere semplice l'esempio, ma questo sarebbe il modo più ovvio per scrivere quel codice:

#include <future> 

class Xxx //non-POD object 
{ 
    int i; 
public: 
    Xxx(int i) : i(i) {} 
    int GetSquare() { return i * i; } 
}; 

int factorial(Xxx xxx) 
{ 
    int res = 1; 
    for(int i = xxx.GetSquare(); i > 1; i--) 
    { 
    res *= i; 
    } 
    return res; 
} 

int main() 
{ 
    Xxx xxx(2); // 2 represents one payload from the socket 
    std::future<int> fu = std::async(factorial, std::move(xxx)); 
    int fact = fu.get(); 
} 

Answer 2

suona come l'implementazione è difettoso. Non ci dovrebbe essere bisogno di un costruttore predefinito (secondo i requisiti generali della biblioteca di [utility.arg.requirements]), e GCC accetta il tuo codice (dopo aver cambiato il Microsoftish strano _tmain in uno standard main).

Passarei a un altro compilatore e sistema operativo. Potrebbe non essere un'opzione per te, quindi potresti dare alla classe un costruttore predefinito per renderlo felice.