Quel est le meilleur/idiomatiques façon à insérer dans une carte?

Tout d'abord, operator[] et insert fonctions de membre ne sont pas fonctionnellement équivalent :

• La operator[] sera de recherche pour la clé, insérez un par défaut construit valeur si elle ne trouve pas, et de renvoyer une référence qui vous permet d'assigner une valeur. Évidemment, cela peut s'avérer inefficace si le mapped_type peuvent être initialisée directement au lieu de la valeur par défaut construit et affecté. Cette méthode ne permet pas de déterminer si l'insertion a bien eu lieu ou si vous avez seulement écrasé à la valeur précédemment inséré la clé
• La insert fonction membre n'aura aucun effet si la clé est déjà présent dans la carte et, bien qu'il est souvent oublié, renvoie un std::pair<iterator, bool> qui peuvent être d'intérêt (notamment pour déterminer si l'insertion a été effectivement le cas).

De tous les possibilités d'appel insert, tous les trois sont presque équivalent. Pour rappel, voyons insert signature dans la norme :

typedef pair<const Key, T> value_type;

  /* ... */

pair<iterator, bool> insert(const value_type& x);

Alors, comment sont les trois appels différents ?

• std::make_pair s'appuie sur l'argument de modèle de déduction et pourrait (et dans ce cas sera) produire quelque chose de différent du réel value_type de la carte, qui va nécessiter un appel supplémentaire à std::pair modèle constructeur afin de convertir value_type (ie : ajouter const à first_type)
• std::pair<int, int> exige aussi un appel supplémentaire au modèle constructeur de std::pair afin de convertir le paramètre value_type (ie : ajouter const à first_type)
• std::map<int, int>::value_type laisse absolument aucune place pour le doute, car il est directement le type de paramètre attendu par le insert fonction membre.

En fin de compte, je voudrais éviter d'utiliser operator[] lorsque l'objectif est d'insérer, à moins qu'il n'y a aucun coût supplémentaire par défaut-de la construction et de l'affectation de la mapped_type, et que je ne se soucient pas de déterminer si une nouvelle clé a effectivement insérée. Lors de l'utilisation de insert, la construction d'un value_type est probablement la voie à suivre.

La première version:

function[0] = 42; //version 1

peut ou peut ne pas insérer la valeur 42 dans la carte. Si la clé 0 existe, alors il va céder à 42 de cette clé, en écrasant la valeur de cette clé. Sinon, il insère la paire clé/valeur.

L'insérer des fonctions:

function.insert(std::map<int, int>::value_type(0, 42));  //version 2
function.insert(std::pair<int, int>(0, 42));             //version 3
function.insert(std::make_pair(0, 42));                  //version 4

d'autre part, de ne rien faire si la clé 0 existe déjà dans la carte. Si la clé n'existe pas, on insère la paire clé/valeur.

Les trois insérer des fonctions sont presque identiques. std::map<int, int>::value_type est le typedef pour std::pair<const int, int>, et std::make_pair() évidemment produit un std::pair<> par modèle déduction de la magie. Le résultat final, cependant, devrait être la même pour les versions 2, 3 et 4.

Lequel dois-je utiliser? Personnellement, je préfère la version 1; il est concis et "naturel". Bien sûr, si son écrasement comportement n'est pas souhaité, puis je préfère la version 4, car il nécessite moins de frappe que les versions 2 et 3. Je ne sais pas si il y a un seul de facto moyen de l'insertion de paires clé/valeur dans un std::map.

Une autre façon d'insérer des valeurs dans une carte via l'un de ses constructeurs:

std::map<int, int> quadratic_func;

quadratic_func[0] = 0;
quadratic_func[1] = 1;
quadratic_func[2] = 4;
quadratic_func[3] = 9;

std::map<int, int> my_func(quadratic_func.begin(), quadratic_func.end());

En bref, [] opérateur est plus efficace pour la mise à jour des valeurs, car il implique l'appel de constructeur par défaut du type de la valeur et en l'affectant une nouvelle valeur, tandis que insert() est plus efficace pour l'ajout de valeurs.

La cité extrait de Efficace STL: 50 Moyens Spécifiques pour Améliorer Votre Utilisation de la Bibliothèque de modèles Standard par Scott Meyers, Article 24, de ce qui pourrait aider.

template<typename MapType, typename KeyArgType, typename ValueArgType>
typename MapType::iterator
insertKeyAndValue(MapType& m, const KeyArgType&k, const ValueArgType& v)
{
typename MapType::iterator lb = m.lower_bound(k);
if (lb != m.end() && !(m.key_comp()(k, lb->first))) {
lb->second = v;
return lb;
} else {
typedef typename MapType::value_type MVT;
return m.insert(lb, MVT(k, v));
}
}

Vous pouvez décider de choisir un des génériques de la programmation-la version gratuite de ce, mais le point est que je trouve ce paradigme (différenciation "ajouter" et "mise à jour") extrêmement utile.

Si vous souhaitez insérer un élément dans std::map - utilisation de l'insert() de la fonction, et si vous voulez trouver de l'élément (par clé) et attribuer certains de il - utiliser l'opérateur[].

Pour simplifier l'insertion d'utiliser boost::attribuer une bibliothèque, comme ceci:

using namespace boost::assign;
//For inserting one element:
insert( function )( 0, 41 );
//For inserting several elements:
insert( function )( 0, 41 )( 0, 42 )( 0, 43 );

Depuis C++17 std::map propose deux nouvelles méthodes d'insertion: insert_or_assign() et try_emplace(), comme mentionné aussi dans le commentaire par sp2danny.

insert_or_assign()

Fondamentalement, insert_or_assign() est une version "améliorée" de operator[]. Contrairement à operator[], insert_or_assign() ne nécessite pas la carte du type de valeur à la valeur par défaut constructible. Par exemple, le code suivant ne compile pas, parce que MyClass ne possède pas de constructeur par défaut:

class MyClass {
public:
MyClass(int i) : m_i(i) {};
int m_i;
};
int main() {
std::map<int, MyClass> myMap;
//VS2017: "C2512: 'MyClass::MyClass' : no appropriate default constructor available"
//Coliru: "error: no matching function for call to 'MyClass::MyClass()"
myMap[0] = MyClass(1);
return 0;
}

Toutefois, si vous remplacez myMap[0] = MyClass(1); par la ligne suivante, puis le code compile et l'insertion se déroule comme prévu:

myMap.insert_or_assign(0, MyClass(1));

En outre, similaire à insert(), insert_or_assign() renvoie une pair<iterator, bool>. La valeur Booléenne est true si l'insertion s'est produite et false si un travail a été fait. L'itérateur points à l'élément qui a été insérée ou mise à jour.

try_emplace()

Similaire à ce qui précède, try_emplace() est une "amélioration" de emplace(). Contrairement à emplace(), try_emplace() ne modifie pas ses arguments si l'insertion échoue à cause d'une clé déjà existante dans la carte. Par exemple, le code suivant tente de emplace un élément avec une clé qui est déjà stocké dans la carte (voir *):

int main() {
std::map<int, std::unique_ptr<MyClass>> myMap2;
myMap2.emplace(0, std::make_unique<MyClass>(1));
auto pMyObj = std::make_unique<MyClass>(2);    
auto [it, b] = myMap2.emplace(0, std::move(pMyObj));  //*
if (!b)
std::cout << "pMyObj was not inserted" << std::endl;
if (pMyObj == nullptr)
std::cout << "pMyObj was modified anyway" << std::endl;
else
std::cout << "pMyObj.m_i = " << pMyObj->m_i <<  std::endl;
return 0;
}

De sortie (au moins pour VS2017 et Coliru):

pMyObj n'a pas été inséré

pMyObj a été modifié de toute façon

Comme vous pouvez le voir, pMyObj plus de points à l'objet d'origine. Toutefois, si vous remplacez auto [it, b] = myMap2.emplace(0, std::move(pMyObj)); par le code suivant, puis la sortie est différent, parce que pMyObj reste inchangé:

auto [it, b] = myMap2.try_emplace(0, std::move(pMyObj));

De sortie:

pMyObj n'a pas été inséré

pMyObj pMyObj.m_i = 2

Code sur Coliru

Veuillez noter: j'ai essayé de garder mes explications courtes et simples que possible afin de les adapter à cette réponse. Pour une approche plus précise et complète la description, je recommande la lecture de cet article sur Couramment le C++.