c++ push_back vs emplace_back




3 Answers

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

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

Es posible pasar un value_type que se reenviará al constructor de copia.

Debido a que reenvía los argumentos, esto significa que si no tiene rvalue, 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 debería ser idéntico a lo que hace push_back . Probablemente es más bien destinado 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
c++ visual-studio-2010 stl c++11 move-semantics

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 rvalue, ¿no veo 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 admitía las plantillas variadas, pero con las plantillas variadic se admitirán en Visual Studio 2013 RC, 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 que un tipo sea movible o que pueda copiarse para la función emplace_back , estrictamente hablando. En el caso del vector<NonCopyableNonMovableObject> , esto no es útil, ya que vector<Object>::value_type necesita un tipo copiable o movible 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 es necesario std::map<Key, NonCopyableNonMovableObject> ni copiarlo nunca más, a diferencia de vector , lo que significa que puede usar std::map mapea efectivamente con un tipo mapeado que no se puede copiar ni mover.




Una más en caso de listas:

// construye los elementos en su lugar.
emplace_back ("elemento");

// Creará un nuevo objeto y luego copiará (o moverá) su valor de argumentos. push_back (explicitDataType {"elemento"});




Related