Quelle est la différence entre unordered_map :: emplace et unordered_map :: insert en C++?

unordered_map::insert copie ou déplace une paire clé-valeur dans le récipient. Il est surchargé d'accepter de référence-à-const ou une référence rvalue:

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 vous permet de vous éviter d'inutiles copie ou déplace par la construction de l'élément en place. Il utilise le transfert parfait et un variadic template pour des arguments au constructeur de la paire clé-valeur:

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

Mais il y a beaucoup de chevauchement entre les deux fonctions. emplace peut être utilisé à l'avant de la copier/déplacer constructeur de la paire clé-valeur qui lui permet d'être utilisé comme insert serait. Cela signifie que l'utilisation de emplace ne garantit pas que vous allez éviter les copies ou se déplace. Aussi la version de insert qui prend une rvalue-référence est en fait basé sur un modèle et accepte tout type P tels que la paire clé-valeur est constructible à partir de P.

Scott Meyers dit:

En principe, la mise en place des fonctions qui doivent parfois être plus efficace
que leur insertion homologues, et ils ne doivent jamais être moins
efficace.

( Edit: Howard Hinnant couru certaines expériences qui a montré parfois insert est plus rapide que emplace)

Si vous certainement ne voulez copier/déplacer dans le conteneur, il peut être judicieux d'utiliser insert parce que vous êtes plus susceptibles d'obtenir une erreur de compilation si vous passez des arguments incorrects. Vous devez être plus prudent, vous êtes de passage le bon arguments pour la mise en place de fonctions.

La plupart des implémentations de unordered_map::emplace sera la cause de la mémoire allouée dynamiquement pour la nouvelle paire même si la carte contient un élément qui touche déjà et la emplace échouera. Cela signifie que si il ya une bonne chance qu'un emplace échoue, vous pourrez obtenir de meilleures performances en utilisant insert pour éviter inutile dynamique de l'allocation mémoire.

Petit exemple:

#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: Sur demande. Il est également possible d'utiliser unordered_map::emplace avec une clé ou une valeur qui prend plus d'un paramètre du constructeur. À l'aide de la std::pair par morceaux constructeur vous pouvez toujours éviter les copies ou se déplace.

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

OriginalL'auteur