push_back vs emplace_back

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

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

Como hay una push_backsobrecarga tomando una referencia de valor no entiendo en qué se emplace_backconvierte el propósito .

Además de lo que dijo el visitante:

La función void emplace_back(Type&& _Val)proporcionada por MSCV10 no es conforme y es redundante, ya que, como ha notado, es estrictamente equivalente apush_back(Type&& _Val) .

Pero la forma real de C ++ 0x emplace_backes realmente útil:void emplace_back(Args&&...) :;

En lugar de tomar un value_type , toma una lista variada de argumentos, lo que significa que ahora puede reenviar perfectamente los argumentos y construir directamente un objeto en un contenedor sin ningún tipo temporal.

Eso es útil porque no importa cuánta inteligencia RVO y movimiento semántico traigan a la mesa, todavía hay casos complicados en los que es probable que un push_back haga copias (o movimientos) innecesarios. Por ejemplo, con la insert()función tradicional de a std::map, debe crear un temporal, que luego se copiará en a std::pair<Key, Value>, que luego se copiará en el mapa:

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);

Entonces, ¿por qué no implementaron la versión correcta de emplace_back en MSVC? En realidad, también me molestó hace un tiempo, así que hice la misma pregunta en el blog de Visual C ++ . Aquí está la respuesta de Stephan T Lavavej, el responsable oficial de la implementación de la biblioteca estándar de Visual C ++ en Microsoft.

P: ¿Las funciones de emplazamiento beta 2 son solo una especie de marcador de posición en este momento?

R: Como ya sabrá, las plantillas variadas no se implementan en VC10. Los simulamos con maquinaria de preprocesador para cosas como make_shared<T>() tuplas y cosas nuevas <functional>. Esta maquinaria de preprocesador es relativamente difícil de usar y mantener. Además, afecta significativamente la velocidad de compilación, ya que tenemos que incluir repetidamente subencabezados. Debido a una combinación de nuestras limitaciones de tiempo y problemas de velocidad de compilación, no hemos simulado plantillas variadas en nuestras funciones de emplazamiento.

Cuando se implementan plantillas variadas en el compilador, puede esperar que las aprovechemos en las bibliotecas, incluidas nuestras funciones de ubicación. Nos tomamos muy en serio la conformidad, pero desafortunadamente no podemos hacer todo de una vez.

Es una decisión comprensible. Todos los que intentaron emular una plantilla variada con trucos horribles del preprocesador saben lo repugnante que es esto.

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

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

Es posible pasar un mensaje value_typeque se enviará al constructor de la 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 debe ser idéntico a lo que push_backhace. Probablemente esté destinado a 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

La optimización para emplace_backse puede demostrar en el siguiente ejemplo.

Para el emplace_backconstructor A (int x_arg)se llamará. Y porque push_back A (int x_arg)se llama primero y luego move A (A &&rhs)se llama.

Por supuesto, el constructor tiene que estar marcado como explicit, pero para el ejemplo actual es bueno eliminar lo explícito.

#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;
}

salida:

call emplace_back:
A (x_arg)

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

Aquí se muestra un buen código para push_back y emplace_back.

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

Puede ver la operación de movimiento en push_back y no en emplace_back.

emplace_backla implementación conforme reenviará argumentos al vector<Object>::value_typeconstructor cuando se agregue al vector. Recuerdo que Visual Studio no admitía plantillas variadas, pero con las plantillas variadas se admitirán en Visual Studio 2013 RC, por lo que supongo que se agregará una firma conforme.

Con emplace_back, si reenvía los argumentos directamente al vector<Object>::value_typeconstructor, no necesita un tipo para ser movible o copiable para la emplace_backfunción, estrictamente hablando. En el vector<NonCopyableNonMovableObject>caso, esto no es útil, ya que vector<Object>::value_type necesita un tipo copiable o móvil para crecer.

Pero tenga en cuenta que esto podría ser útil std::map<Key, NonCopyableNonMovableObject>, ya que una vez que asigna una entrada en el mapa, ya no es necesario moverla ni copiarla , a diferencia de vector, lo que significa que puede usarla std::mapefectivamente con un tipo mapeado que no sea copiable ni móvil.

Uno más en caso de listas:

// 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 de uso específico para emplace_back: Si necesita crear un objeto temporal que luego será empujado a un contenedor, use en emplace_backlugar depush_back . Creará el objeto en el lugar dentro del contenedor.

Notas:

1. push_backen el caso anterior creará un objeto temporal y lo moverá al contenedor. Sin embargo, la construcción en el lugar utilizada emplace_backsería más eficiente que construir y luego mover el objeto (lo que generalmente implica alguna copia).
2. En general, puede usar en emplace_backlugar de push_backen todos los casos sin muchos problemas. (Ver excepciones )