push_back vs emplace_back

emplace_back sollte kein Argument vom Typ vector::value_type annehmen, sondern verschiedene Argumente, die an den Konstruktor des angehängten Elements weitergeleitet werden.

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

Es ist möglich, einen value_type zu übergeben, der an den Kopierkonstruktor weitergeleitet wird.

Da die Argumente weitergeleitet werden, bedeutet dies, dass der Container eine "kopierte" Kopie und keine verschobene Kopie speichert, wenn Sie keinen Wert haben.

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

Aber das Obige sollte identisch sein mit dem, was Push_back tut. Es ist wahrscheinlich eher für Anwendungsfälle gedacht wie:

 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

Die Optimierung für emplace_back kann im nächsten Beispiel demonstriert werden.

Für emplace_back wird der Konstruktor A (int x_arg) aufgerufen. Und für Push_backA (int x_arg) wird zuerst und danach move A (A &&rhs) aufgerufen.

Natürlich muss der Konstruktor als explicit markiert sein, aber für das aktuelle Beispiel ist es gut, explizite Aussagen zu entfernen.

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

ausgabe:

call emplace_back:
A (x_arg)

call Push_back:
A (x_arg)
A (A &&)

Die emplace_back -konforme Implementierung leitet Argumente an den vector<Object>::value_type -Konstruktor weiter, wenn sie zum Vektor hinzugefügt werden. Ich erinnere mich, dass Visual Studio keine variadischen Vorlagen unterstützt hat, aber mit variadischen Vorlagen wird Visual Studio 2013 RC unterstützt, daher wird vermutlich eine entsprechende Signatur hinzugefügt.

Wenn Sie mit emplace_back die Argumente direkt an den Konstruktor vector<Object>::value_type weiterleiten, muss ein Typ für die Funktion emplace_back nicht unbedingt verschiebbar oder kopierbar sein. Im Fall von vector<NonCopyableNonMovableObject> ist dies nicht sinnvoll, da vector<Object>::value_type einen kopierbaren oder beweglichen Typ benötigt, um zu wachsen.

Aber beachte dass dies nützlich sein könnte für std::map<Key, NonCopyableNonMovableObject>, da ein einmal zugewiesener Eintrag in der Map nicht mehr verschoben oder kopiert werden muss, im Gegensatz zu vector, was bedeutet, dass Sie std::map effektiv mit einem zugeordneten Typ verwenden können, der weder kopierbar noch verschiebbar ist.

Ein Nizza Code für das Push_back und das emplace_back wird hier gezeigt.

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

Sie können den Verschiebevorgang bei Push_back und nicht bei emplace_back sehen.

Eine weitere bei Listen:

// 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"});