Czy std :: obietnica może być wykonana z obiektu innego niż POD?

Question

Jedną z rzeczy, którą robi moja aplikacja, jest słuchanie i odbieranie ładunków z gniazda. Nigdy nie chcę blokować. Na każdym odebranym ładunku, chcę utworzyć obiekt i przekazać go do wątku roboczego i zapomnieć o nim dopiero później, jak działa prototypowy kod. Ale dla kodu produkcyjnego chcę zmniejszyć złożoność (moja aplikacja jest duża) za pomocą wygodnej metody asynchronicznej. async bierze przyszłość z obietnicy. Aby to działało, muszę utworzyć obietnicę na moim obiekcie nie-POD reprezentowanym poniżej przez klasę Xxx. Nie widzę sposobu, aby to zrobić (zobacz błąd w moim przykładowy kod poniżej). Czy warto tutaj używać asynchronicznego? Jeśli tak, to w jaki sposób można skonstruować obietnica/przyszłego obiektu, który jest bardziej skomplikowane niż int (wszystkie przykłady kodu mam zobaczyć użyć int lub 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

Jak Mike już odpowiedział, to na pewno błąd w implementacji Visual C++ z std::promise, to, co robisz, powinno zadziałać.

Ale jestem ciekawy, dlaczego i tak trzeba to zrobić. Może jest jeszcze jakiś inny wymóg, którego nie pokazałeś, aby przykład był prosty, ale byłby to oczywisty sposób napisania tego kodu:

#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

Brzmi jak implementacja jest uszkodzony. Nie powinno być potrzeby domyślnego konstruktora (zgodnie z ogólnymi wymaganiami biblioteki [utility.arg.requirements]), a GCC akceptuje twój kod (po zmianie dziwnego Microsoftish _tmain na standardowy main).

Przestawiłbym się na inny kompilator i system operacyjny. To może nie być opcja dla ciebie, więc może możesz dać klasie domyślny konstruktor, aby był szczęśliwy.