Efficienza di C ++ 11 push_back () con std :: move rispetto a emplace_back () per oggetti già costruiti

In C ++ 11 emplace_back()è generalmente preferito (in termini di efficienza) in push_back()quanto consente la costruzione sul posto, ma è ancora così quando si utilizzapush_back(std::move()) con un oggetto già costruito?

Ad esempio, è emplace_back()ancora preferito in casi come i seguenti?

std::string mystring("hello world");
std::vector<std::string> myvector;

myvector.emplace_back(mystring);
myvector.push_back(std::move(mystring));
// (of course assuming we don't care about using the value of mystring after)

Inoltre, nell'esempio precedente c'è qualche vantaggio nel fare invece:

myvector.emplace_back(std::move(mystring));

o il trasferimento qui è del tutto ridondante o non ha alcun effetto?

Vediamo cosa fanno le diverse chiamate che hai fornito:

1. emplace_back(mystring): Questa è una costruzione sul posto del nuovo elemento con qualsiasi argomento fornito. Dato che hai fornito un valore l, quella costruzione sul posto in effetti è una costruzione di copia, cioè è lo stesso che chiamarepush_back(mystring)

2. push_back(std::move(mystring)): Questo chiama l'inserimento della mossa, che nel caso di std::stringè una costruzione del movimento sul posto.

3. emplace_back(std::move(mystring)): Anche questa è una costruzione sul posto con gli argomenti che hai fornito. Poiché quell'argomento è un valore, chiama il costruttore di mosse di std::string, cioè è una costruzione di mosse sul posto come in 2.

In altre parole, se chiamato con un argomento di tipo T, sia esso un rvalue o lvalue, emplace_backe push_backsono equivalenti.

Tuttavia, per qualsiasi altro argomento, emplace_backvince la gara, ad esempio con a char const*in a vector<string>:

4. emplace_back("foo")chiede la std::string(char const*)costruzione sul posto.

5. push_back("foo")prima deve richiedere std::string(char const*)la conversione implicita necessaria per abbinare la firma della funzione, e quindi un inserimento di spostamento come nel caso 2. sopra. Quindi è equivalente apush_back(string("foo"))

Emplace_back ottiene un elenco di riferimenti rvalue e cerca di costruire un elemento contenitore direttamente sul posto. Puoi chiamare emplace_back con tutti i tipi supportati dai costruttori dell'elemento contenitore. Quando si chiama emplace_back per parametri che non sono riferimenti rvalue, "ricade" sui riferimenti normali e almeno il costruttore di copia viene chiamato quando il parametro e gli elementi contenitore sono dello stesso tipo. Nel tuo caso 'myvector.emplace_back (mystring)' dovrebbe fare una copia della stringa perché il compilatore non poteva sapere che il parametro myvector è mobile. Quindi inserisci std :: move ciò che ti dà il vantaggio desiderato. Il push_back dovrebbe funzionare come emplace_back per gli elementi già costruiti.