std :: filo con mobile, argomento non copiabile

Question

Il seguente programma non costruisce in VS11 beta, gcc 4.5, o clang 3,1

#include <thread> 
#include <memory> 

int main() { 
    std::unique_ptr<int> p; 
    std::thread th([](std::unique_ptr<int>) { 

    },std::move(p)); 
    th.join(); 
} 

Questo perché il tipo argomento non è copiabile, ma la l'implementazione tenta di copiarlo.

Per quanto posso dire, questo programma è ben strutturato e dovrebbe funzionare. I requisiti per std :: thread sembrano implicare che gli argomenti mobili e non copiabili dovrebbero funzionare qui. In particolare, afferma che l'oggetto chiamabile e ciascun argomento devono soddisfare i requisiti MoveConstructible e che INVOKE(DECAY_COPY(std::forward<F>(f)),DECAY_COPY(std::forward<Args>(args))...) deve essere un'espressione valida.

In questo caso penso che l'espressione funziona a qualcosa di simile:

template <class T> typename std::decay<T>::type decay_copy(T&& v) 
{ return std::forward<T>(v); } 

std::unique_ptr<int> p; 
auto f = [](std::unique_ptr<int>) {}; 

decay_copy(f)(decay_copy(std::move(p))); 

E non credo che questo dovrebbe comportare una copia di p. gcc almeno può compilare questa espressione, sebbene VS11 no.

1. Mi sbaglio sui requisiti e gli argomenti devono essere copiabili?
2. Lo standard lascia un margine di manovra su questo problema perché le implementazioni copino gli argomenti?
3. Oppure l'implementazione che ho provato non conforme?

Answer 1

Da 30.3.1.2, comma 3 e 4 del N3337:

template <class F, class ...Args> explicit thread(F&& f, Args&&... args);

Richiede: F e ogni Ti in Args deve soddisfare la MoveConstructible requisiti. INVOKE (DECAY_-COPY (std::forward<F>(f)), DECAY_COPY (std::forward<Args>(args))...) (20.8.2) deve essere un'espressione valida.

Effetti: costruisce un oggetto di tipo thread. Il nuovo thread di esecuzione viene eseguito INVOKE (DECAY_-COPY (std::forward<F>(f)), DECAY_COPY (std::forward<Args>(args))...) con le chiamate a DECAY_COPY in corso di valutazione nel thread di costruzione. Qualsiasi valore di ritorno da questa invocazione viene ignorato. [Nota: ciò implica che eventuali eccezioni non generate dall'invocazione della copia di f verranno generate nel thread di costruzione, non nel nuovo thread. -end note] Se l'invocazione di INVOKE (DECAY_COPY (std::forward<F>(f)), DECAY_COPY (std::forward<Args>(args))...) termina con un'eccezione non rilevata, viene chiamato std :: terminate.

Quindi sì, questo dovrebbe funzionare. In caso contrario, questo è un bug nella tua implementazione.

Si noti che qualsiasi movimento/copia di parametri avverrà sul nuovo thread. Stai trasmettendo riferimenti a un altro thread, quindi devi assicurarti che esistano ancora fino all'avvio del thread.

Answer 2

In alternativa, e come standard std::thread linguaggio, è possibile passare un involucro di riferimento:

int p; 
std::thread([](int & x) { /* ... */ }, std::ref(p)); 

Questo crea un oggetto di tipo std::reference_wrapper<int>, che ha semantica di valore e avvolge un riferimento a un int (ie copiare il wrapper fa il riferimento al riferimento).