std :: thread Perché l'oggetto viene copiato due volte?

Question

Perché nel seguente codice di esempio, l'oggetto viene copiato due volte? Secondo il costruttore di documentazione della classe thread, copia tutti gli argomenti sull'archiviazione thread-locale, quindi abbiamo un motivo per la prima copia. Che dire del secondo?

class A { 
public: 
    A() {cout << "[C]" << endl;} 
    ~A() {cout << "[~D]" << endl;} 
    A(A const& src) {cout << "[COPY]" << endl;} 
    A& operator=(A const& src) {cout << "[=}" << endl; return *this;} 

    void operator()() {cout << "#" << endl;} 
}; 

void foo() 
{ 
    A a; 
    thread t{a}; 
    t.join(); 
} 

uscita dall'alto:

[C] 
[COPY] 
[COPY] 
[~D] 
# 
[~D] 
[~D] 

Edit: Ebbene sì, dopo l'aggiunta di movimento costruttore:

A(A && src) {cout << "[MOVE]" << endl;} 

L'output è simile a questo:

[C] 
[COPY] 
[MOVE] 
[~D] 
# 
[~D] 
[~D] 

Answer 1

Per qualsiasi cosa si desidera spostare o evitare le copie, preferire i costruttori di movimento e std::move.

Ma perché questo non accade automaticamente per me?

Il passaggio in C++ è conservativo. Solitamente si muoverà solo se scrivi esplicitamente std::move(). Ciò è stato fatto perché spostare la semantica, se estesa oltre circostanze molto esplicite, potrebbe interrompere il codice precedente. Le mosse automatiche sono spesso limitate a un insieme di circostanze molto attente per questo motivo.

Per evitare copie in questa situazione, è necessario spostare a utilizzando std::move(a) (anche quando lo si passa in std::thread). Il motivo per cui esegue una copia la prima volta è perché std :: thread non può garantire che il valore esisterà dopo aver terminato la costruzione di std :: thread (e non lo si è spostato in modo esplicito). Così, farà la cosa sicura e farà una copia (non prendere un riferimento/puntatore a ciò che hai passato e memorizzarlo: il codice non ha idea se lo manterrai o meno).

Avere sia un costruttore di spostamenti che l'uso di std::move consentirà al compilatore di spostare la propria struttura in modo ottimale ed efficiente. Se si utilizza VC++ (con CTP o meno), è necessario scrivere esplicitamente il costruttore di movimento, altrimenti MSVC (anche a volte erroneamente) dichiarerà e utilizzerà un costruttore di copia.

Answer 2

prova con: thread t {std :: m ove (a)};