[c++] push_back vs emplace_back


Answers

emplace_back no debería tomar un argumento de tipo vector::value_type , sino argumentos variados que se reenvían al constructor del elemento adjunto.

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

Es posible pasar un value_type que será reenviado al constructor de copia.

Debido a que reenvía los argumentos, esto significa que si no tiene el valor r, esto significa que el contenedor almacenará una copia "copiada", no una copia movida.

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

Pero lo anterior debe ser idéntico a lo que push_back hace. Probablemente sea más adecuado para casos de uso como:

 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
Question

Estoy un poco confundido con respecto a la diferencia entre push_back y emplace_back .

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

Como hay una sobrecarga push_back toma una referencia de valor real, ¿no veo exactamente cuál es el propósito de emplace_back ?




emplace_back implementación conforme con emplace_back reenviará argumentos al vector<Object>::value_type constructor cuando se agregue al vector. Recuerdo que Visual Studio no admitió plantillas variadic, pero con Visual Studio 2013 RC se admitirán plantillas variad, así que supongo que se agregará una firma conforme.

Con emplace_back , si reenvía los argumentos directamente al vector<Object>::value_type constructor, no necesita un tipo para ser movible o que se pueda copiar para la función emplace_back , estrictamente hablando. En el caso del vector<NonCopyableNonMovableObject> , esto no es útil, ya que el vector<Object>::value_type necesita un tipo que se pueda copiar o mover para crecer.

Pero tenga en cuenta que esto podría ser útil para std::map<Key, NonCopyableNonMovableObject> , ya que una vez que asigna una entrada en el mapa, no necesita moverse o copiarse nunca más, a diferencia de vector , lo que significa que puede usar std::map con eficacia con un tipo mapeado que no se puede copiar ni mover.







Links