push_back vs emplace_back

Ich bin etwas verwirrt über den Unterschied zwischen push_backund emplace_back.

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

Da es eine push_backÜberlastung gibt, die eine R-Wert-Referenz nimmt, sehe ich nicht ganz, wozu der Zweck emplace_backwird?

Zusätzlich zu dem, was der Besucher sagte:

Die void emplace_back(Type&& _Val)von MSCV10 bereitgestellte Funktion ist nicht konform und redundant, da sie, wie Sie bemerkt haben, streng gleichwertig ist mit push_back(Type&& _Val).

Aber die echte C ++ 0x-Form von emplace_backist wirklich nützlich : void emplace_back(Args&&...);

Anstatt a zu nehmen value_type, wird eine variable Liste von Argumenten verwendet, was bedeutet, dass Sie die Argumente jetzt perfekt weiterleiten und ein Objekt direkt in einen Container ohne temporäre Elemente konstruieren können.

Das ist nützlich, denn egal wie viel Klugheit RVO und Bewegungssemantik auf den Tisch bringen, es gibt immer noch komplizierte Fälle, in denen ein push_back wahrscheinlich unnötige Kopien (oder Verschiebungen) erstellt. Zum Beispiel müssen Sie mit der traditionellen insert()Funktion von a std::mapeine temporäre Funktion erstellen, die dann in a kopiert std::pair<Key, Value>wird und dann in die Karte kopiert wird:

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

Warum haben sie nicht die richtige Version von emplace_back in MSVC implementiert? Eigentlich hat es mich vor einiger Zeit auch nervt, also habe ich die gleiche Frage im Visual C ++ - Blog gestellt . Hier ist die Antwort von Stephan T Lavavej, dem offiziellen Betreuer der Implementierung der Visual C ++ - Standardbibliothek bei Microsoft.

F: Sind Beta 2 Emplace-Funktionen derzeit nur eine Art Platzhalter?

A: Wie Sie vielleicht wissen, sind in VC10 keine variablen Vorlagen implementiert. Wir simulieren sie mit Präprozessor-Maschinen für Dinge wie make_shared<T>()Tupel und die neuen Dinge in <functional>. Diese Präprozessor-Maschine ist relativ schwierig zu bedienen und zu warten. Dies wirkt sich auch erheblich auf die Kompilierungsgeschwindigkeit aus, da wir wiederholt Unterüberschriften einbeziehen müssen. Aufgrund einer Kombination aus Zeitbeschränkungen und Bedenken hinsichtlich der Kompilierungsgeschwindigkeit haben wir in unseren Emplace-Funktionen keine variablen Vorlagen simuliert.

Wenn verschiedene Vorlagen im Compiler implementiert sind, können Sie davon ausgehen, dass wir sie in den Bibliotheken, einschließlich unserer Emplace-Funktionen, nutzen. Wir nehmen Konformität sehr ernst, aber leider können wir nicht alles auf einmal tun.

Es ist eine verständliche Entscheidung. Jeder, der nur einmal versucht hat, eine variable Vorlage mit schrecklichen Tricks des Präprozessors zu emulieren, weiß, wie ekelhaft dieses Zeug wird.

emplace_backsollte kein Argument vom Typ vector::value_typeannehmen, 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, eine zu übergeben, value_typedie 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 r-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_backtut. 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_backkann im nächsten Beispiel demonstriert werden.

Für emplace_backKonstruktor A (int x_arg)wird aufgerufen. Und denn push_back A (int x_arg)heißt zuerst und move A (A &&rhs)wird danach gerufen.

Natürlich muss der Konstruktor als markiert werden explicit, 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 &&)

Ein netter Code für push_back und emplace_back wird hier gezeigt.

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

Sie können den Verschiebevorgang auf push_back und nicht auf emplace_back sehen.

emplace_backEine konforme Implementierung leitet Argumente an den vector<Object>::value_typeKonstruktor weiter, wenn sie dem Vektor hinzugefügt werden. Ich erinnere mich, dass Visual Studio keine variadic-Vorlagen unterstützt hat, aber mit variadic-Vorlagen in Visual Studio 2013 RC unterstützt wird, wird vermutlich eine konforme Signatur hinzugefügt.

Mit emplace_back, wenn Sie die Argumente direkt weiterleiten vector<Object>::value_typeKonstruktor, nicht wahr eine Art benötigt für bewegliche oder kopierbar seine emplace_backFunktion, genau genommen. In diesem vector<NonCopyableNonMovableObject>Fall ist dies nicht sinnvoll, da vector<Object>::value_type zum Wachsen ein kopierbarer oder beweglicher Typ erforderlich ist.

Aber zur Kenntnis , dass dies für sinnvoll sein könnte std::map<Key, NonCopyableNonMovableObject>, da , wenn Sie einen Eintrag in der Karte zuzuordnen, ist es nicht bewegt werden muß oder überhaupt nicht mehr kopiert werden , im Gegensatz zu vector, was bedeutet , dass Sie verwenden können , std::mapeffektiv mit einem zugeordneten Typ, der weder kopierbar ist noch beweglich.

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

Spezifischer Anwendungsfall für emplace_back: Wenn Sie ein temporäres Objekt erstellen müssen, das dann in einen Container verschoben wird, verwenden Sie emplace_backanstelle vonpush_back . Das Objekt wird direkt im Container erstellt.

Anmerkungen:

1. push_backIm obigen Fall wird ein temporäres Objekt erstellt und in den Container verschoben. In-Place-Konstruktion verwendet füremplace_back die verwendet wird, ist jedoch leistungsfähiger als das Konstruieren und anschließende Verschieben des Objekts (was im Allgemeinen ein Kopieren erfordert).
2. Im Allgemeinen können Sie emplace_backstatt push_backin allen Fällen ohne große Probleme verwenden. (Siehe Ausnahmen )