kann ein std :: promise von einem Nicht-POD-Objekt gemacht werden?

Question

Eines meiner Programme ist das Abhören und Empfangen von Payloads von einem Socket. Ich möchte nie blocken. Für jede empfangene Nutzlast möchte ich ein Objekt erstellen und es an einen Worker-Thread übergeben und es später vergessen, so wie der Prototyp-Code funktioniert. Aber für den Produktionscode möchte ich die Komplexität reduzieren (meine App ist groß), indem ich die bequeme Async-Methode verwende. async nimmt eine Zukunft, die aus einem Versprechen gemacht wird. Damit das funktioniert, muss ich ein Versprechen für mein Nicht-POD-Objekt erstellen, das unten durch die Xxx-Klasse repräsentiert wird. Ich sehe keine Möglichkeit, dies zu tun (siehe Fehler in meinem Beispielcode unten). Ist es angemessen, hier Async zu verwenden? Wenn ja, wie kann ich ein Versprechen/future-Objekt erstellen, die komplexen als int (alle Code-Beispiele Ich habe sehen entweder Verwendung int oder 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

Wie Mike bereits geantwortet hat, ist es definitiv ein Fehler in der Visual C++ - Implementierung von std::promise, was Sie tun sollten, sollte funktionieren.

Aber ich bin neugierig, warum Sie es trotzdem tun müssen. Vielleicht gibt es eine andere Anforderung, die Sie nicht gezeigt haben, um das Beispiel einfach zu halten, aber das wäre die offensichtliche Möglichkeit, diesen Code zu schreiben:

#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

Es klingt wie Ihre Implementierung defekt ist. Es sollte keinen Standardkonstruktor geben (gemäß den allgemeinen Bibliotheksanforderungen von [Dienstprogramm.Arg.Anforderungen]), und GCC akzeptiert Ihren Code (nach dem Ändern des seltsamen Microsoftish _tmain zu einem Standard main).

Ich würde zu einem anderen Compiler und Betriebssystem wechseln. Das ist vielleicht keine Option für Sie, also könnten Sie der Klasse vielleicht einen Standardkonstruktor geben, um es glücklich zu machen.