push_back vs emplace_back

Sono un po 'confuso riguardo alla differenza tra push_backe emplace_back.

void emplace_back(Type&& _Val);
void push_back(const Type& _Val);
void push_back(Type&& _Val);

Dato che c'è un push_backsovraccarico che prende un riferimento di valore, non vedo esattamente quale sia lo scopo di emplace_back?

Oltre a ciò che il visitatore ha detto:

La funzione void emplace_back(Type&& _Val)fornita da MSCV10 non è conforme e ridondante, perché come hai notato è strettamente equivalente a push_back(Type&& _Val).

Ma la vera forma C ++ 0x di emplace_backè davvero utile void emplace_back(Args&&...):;

Invece di prendere un value_typeprende un elenco variadico di argomenti, quindi ciò significa che ora puoi inoltrare perfettamente gli argomenti e costruire direttamente un oggetto in un contenitore senza un temporaneo.

Questo è utile perché non importa quanta intelligenza l'RVO e lo spostamento semantico portano al tavolo ci sono ancora casi complicati in cui è probabile che un push_back faccia copie (o spostamenti) non necessarie. Ad esempio, con la tradizionale insert()funzione di a std::map, devi creare un temporaneo, che verrà quindi copiato in a std::pair<Key, Value>, che verrà quindi copiato nella mappa:

std::map<int, Complicated> m;
int anInt = 4;
double aDouble = 5.0;
std::string aString = "C++";

// cross your finger so that the optimizer is really good
m.insert(std::make_pair(4, Complicated(anInt, aDouble, aString))); 

// should be easier for the optimizer
m.emplace(4, anInt, aDouble, aString);

Quindi perché non hanno implementato la versione corretta di emplace_back in MSVC? In realtà, mi ha infastidito troppo tempo fa, quindi ho posto la stessa domanda sul blog di Visual C ++ . Ecco la risposta di Stephan T Lavavej, manutentore ufficiale dell'implementazione della libreria standard Visual C ++ presso Microsoft.

D: Le funzioni di beta 2 emplace sono solo una specie di segnaposto in questo momento?

A: Come forse saprai, i modelli variadic non sono implementati in VC10. Li simuliamo con macchinari preprocessore per cose come make_shared<T>(), la tupla e le cose nuove <functional>. Questo macchinario preprocessore è relativamente difficile da usare e mantenere. Inoltre, influisce in modo significativo sulla velocità di compilazione, poiché dobbiamo includere ripetutamente i sottotitoli. A causa di una combinazione dei nostri vincoli temporali e problemi di velocità della compilazione, non abbiamo simulato modelli variadici nelle nostre funzioni di emplace.

Quando i modelli variadic sono implementati nel compilatore, puoi aspettarti che ne trarremo vantaggio nelle librerie, anche nelle nostre funzioni di emplace. Prendiamo molto sul serio la conformità, ma sfortunatamente non possiamo fare tutto in una volta.

È una decisione comprensibile. Chiunque abbia provato una sola volta a emulare il modello variadico con trucchi orribili del preprocessore sa quanto sia disgustosa questa roba.

emplace_backnon dovrebbe prendere un argomento di tipo vector::value_type, ma piuttosto argomenti vari che vengono inoltrati al costruttore dell'elemento aggiunto.

template <class... Args> void emplace_back(Args&&... args); 

È possibile passare un value_typeche verrà inoltrato al costruttore della copia.

Poiché inoltra gli argomenti, ciò significa che se non si dispone di rvalue, ciò significa che il contenitore memorizzerà una copia "copiata", non una copia spostata.

 std::vector<std::string> vec;
 vec.emplace_back(std::string("Hello")); // moves
 std::string s;
 vec.emplace_back(s); //copies

Ma quanto sopra dovrebbe essere identico a quello che push_backfa. Probabilmente è piuttosto pensato per casi d'uso come:

 std::vector<std::pair<std::string, std::string> > vec;
 vec.emplace_back(std::string("Hello"), std::string("world")); 
 // should end up invoking this constructor:
 //template<class U, class V> pair(U&& x, V&& y);
 //without making any copies of the strings

L'ottimizzazione per emplace_backpuò essere dimostrata nel prossimo esempio.

Per il emplace_backcostruttore A (int x_arg)verrà chiamato. E perché push_back A (int x_arg)viene chiamato per primo e move A (A &&rhs)dopo viene chiamato.

Certo, il costruttore deve essere contrassegnato come explicit, ma per l'esempio attuale è bene rimuovere la spiegazione.

#include <iostream>
#include <vector>
class A
{
public:
  A (int x_arg) : x (x_arg) { std::cout << "A (x_arg)\n"; }
  A () { x = 0; std::cout << "A ()\n"; }
  A (const A &rhs) noexcept { x = rhs.x; std::cout << "A (A &)\n"; }
  A (A &&rhs) noexcept { x = rhs.x; std::cout << "A (A &&)\n"; }

private:
  int x;
};

int main ()
{
  {
    std::vector<A> a;
    std::cout << "call emplace_back:\n";
    a.emplace_back (0);
  }
  {
    std::vector<A> a;
    std::cout << "call push_back:\n";
    a.push_back (1);
  }
  return 0;
}

produzione:

call emplace_back:
A (x_arg)

call push_back:
A (x_arg)
A (A &&)

Un bel codice per push_back ed emplace_back è mostrato qui.

http://en.cppreference.com/w/cpp/container/vector/emplace_back

Puoi vedere l'operazione di spostamento su push_back e non su emplace_back.

emplace_backun'implementazione conforme inoltra gli argomenti al vector<Object>::value_typecostruttore quando viene aggiunta al vettore. Ricordo che Visual Studio non supportava i modelli variadic, ma con i modelli variadic sarà supportato in Visual Studio 2013 RC, quindi suppongo che verrà aggiunta una firma conforme.

Con emplace_back, se inoltri gli argomenti direttamente al vector<Object>::value_typecostruttore, non hai bisogno di un tipo per essere mobile o copiabile per la emplace_backfunzione, a rigor di termini. Nel vector<NonCopyableNonMovableObject>caso, questo non è utile, poiché ha vector<Object>::value_type bisogno di un tipo copiabile o mobile per crescere.

Ma nota che questo potrebbe essere utile std::map<Key, NonCopyableNonMovableObject>, poiché una volta allocata una voce nella mappa, non è più necessario spostarla o copiarla, a differenza di vector, il che significa che puoi usarla std::mapefficacemente con un tipo mappato che non è né copiabile né mobile.

Ancora uno in caso di liste:

// constructs the elements in place.                                                
emplace_back("element");


//It will create new object and then copy(or move) its value of arguments.
push_back(explicitDataType{"element"});

Caso d'uso specifico per emplace_back: se è necessario creare un oggetto temporaneo che verrà quindi inserito in un contenitore, utilizzare emplace_backinvece dipush_back . Creerà l'oggetto sul posto all'interno del contenitore.

Appunti:

1. push_backnel caso precedente creerà un oggetto temporaneo e lo sposterà nel contenitore. Tuttavia, la costruzione in loco utilizzata emplace_backsarebbe più performante della costruzione e quindi dello spostamento dell'oggetto (che generalmente comporta alcune copie).
2. In generale, è possibile utilizzare emplace_backanziché push_backin tutti i casi senza problemi. (Vedi eccezioni )