Was ist der Unterschied zwischen unordered_map :: emplace und unordered_map :: insert in C++?

unordered_map::insert kopiert oder verschiebt ein Schlüssel-Wert-paar in den container ein. Es ist überladen zu akzeptieren Referenz auf const oder eine rvalue-Referenz:

std::pair<iterator,bool> insert(const std::pair<const Key, T>& value);

template<class P>
std::pair<iterator,bool> insert(P&& value);

unordered_map::emplace können Sie, zur Vermeidung unnötiger kopiert oder verschiebt, indem er das element im Ort. Es nutzt perfect forwarding und ein variadic template Argumente an den Konstruktor der Schlüssel-Wert-paar:

template<class... Args>
std::pair<iterator,bool> emplace(Args&&... args);

Aber es gibt eine große überlappung zwischen den beiden Funktionen. emplace können verwendet werden, um vorwärts zu der copy/move-Konstruktor der Schlüssel-Wert-paar und erlaubt es, um verwendet werden, wie insert würde. Dies bedeutet, dass die Verwendung von emplace nicht garantieren, dass Sie vermeiden, kopiert oder verschiebt. Auch die version von insert nimmt eine rvalue-Referenz ist tatsächlich Vorlagen und akzeptiert jede Art P so, dass der Schlüssel-Wert-paar ist bebaubar von P.

Scott Meyers sagt:

Im Prinzip, Verlegung Funktionen sollten manchmal effizienter sein
als Ihre insertion Kollegen, und Sie sollten nie weniger
effizient ist.

( Edit: Howard Hinnant lief einige Experimentedie zeigte, dass manchmal insert ist schneller als emplace)

Wenn Sie definitiv möchten, kopieren/verschieben in den container ist es ratsam, zu verwenden insert denn Sie sind mehr wahrscheinlich, um einen Kompilierungsfehler, wenn Sie falsche Argumente. Sie müssen vorsichtiger sein, Sie sind vorbei die richtigen Argumente, um die Einlagerung von Funktionen.

Meisten Implementierungen von unordered_map::emplace verursachen wird Speicher dynamisch allokiert sein für das neue paar, auch wenn die Karte enthält ein Element mit diesem Schlüssel bereits und die emplace fehl. Dies bedeutet, dass, wenn es eine gute chance, dass ein emplace fehl, erhalten Sie möglicherweise eine bessere Leistung, die Verwendung von insert zu vermeiden, unnötige dynamische Zuweisung von Arbeitsspeicher.

Kleines Beispiel:

#include <unordered_map>
#include <iostream>

int main() {
  auto employee1 = std::pair<int, std::string>{1, "John Smith"};

  auto employees = std::unordered_map<int, std::string>{};

  employees.insert(employee1);  //copy insertion
  employees.insert(std::make_pair(2, "Mary Jones"));  //move insertion 
  employees.emplace(3, "James Brown");  //construct in-place

  for (const auto& employee : employees)
    std::cout << employee.first << ": " << employee.second << "\n";
}

Edit2: Auf Anfrage. Es ist auch möglich, mit unordered_map::emplace mit einem Schlüssel oder Wert, der mehr als eine Konstruktor-parameter. Mit der std::pair stückweise Konstruktor Sie können immer noch unnötige kopiert oder verschiebt.

#include <unordered_map>
#include <iostream>

struct Employee {
  std::string firstname;
  std::string lastname;
  Employee(const std::string& firstname, const std::string& lastname) 
  : firstname(firstname), lastname(lastname){}    
};

int main() {
  auto employees = std::unordered_map<int, Employee>{};
  auto employee1 = std::pair<int, Employee>{1, Employee{"John", "Smith"}};

  employees.insert(employee1);  //copy insertion
  employees.insert(std::make_pair(2, Employee{"Mary", "Jones"}));  //move insertion
  employees.emplace(3, Employee("Sam", "Thomas")); //emplace with pre-constructed Employee
  employees.emplace(std::piecewise_construct,
                    std::forward_as_tuple(4),
                    std::forward_as_tuple("James", "Brown"));  //construct in-place
}

InformationsquelleAutor der Antwort Chris Drew