Le moyen le plus efficace pour affecter des valeurs à des cartes

1) peut être un peu plus lent que les autres méthodes car std::map::operator[] premier défaut-crée l'objet, si elle n'existe pas déjà, puis renvoie une référence que vous pouvez utiliser operator= sur pour définir la valeur souhaitée, c'est à dire deux opérations.

2-4) doit être équivalent depuis map::value_type est un typedef pour std::pair pour les mêmes types, et donc make_pair est également équivalent. Le compilateur doit traiter de la même manière.

Également noter que le rendement peut être encore plus élevé si vous avez besoin à la fois de vérifier l'existence (par exemple pour effectuer une logique spéciale selon qu'il existe ou pas) et puis aussi l'insérer, en utilisant map::lower_bound d'abord obtenir un indice, à l'endroit où l'élément doit être, donc, map::insert n'a pas à rechercher l'ensemble map de nouveau:

 //get the iterator to where the key *should* be if it existed:
 std::map::iterator hint = mymap.lower_bound(key);

 if (hint == mymap.end() || mymap.key_comp()(key, hint->first)) {
     //key didn't exist in map
     //special logic A here...

     //insert at the correct location
     mymap.insert(hint, make_pair(key, new_value));
 } else { 
     //key exists in map already
     //special logic B here...

     //just update value
     hint->second = new_value;
 }

OriginalL'auteur Anders Johansson

Si il n'y a pas d'objet à l'emplacement de la clé, puis:

std::map::emplace est le plus efficace. insert est deuxième (mais sera très proche). [] est moins efficace.

[], si il n'y a pas d'objet, trivial constructions. Il appelle ensuite operator=.

insert un constructeur de copie d'appel sur le std::pair argument.

Toutefois, dans le cas de cartes, map.insert( make_pair( std::move(key), std::move(value) ) ) va être proche de map.emplace( std::move(key), std::move(value) ).

Si il y a un objet à l'emplacement de la clé, puis [] appellera operator=, tandis que insert/emplace va détruire l'ancien objet et en créer un nouveau. [] pourrait facilement être moins cher dans ce cas.

En fin de compte, cela dépend de ce que votre operator= vs copier-construire vs trivial-construire vs destructeur frais sont à votre clé et la valeur.

Le travail réel à la recherche des choses à l'intérieur de la structure de l'arbre de la std::map sera si près identiques, il n'est pas drôle.

OriginalL'auteur Yakk - Adam Nevraumont

Même si il y a eu une couple de bonnes réponses déjà j'ai pensé que je pourrais aussi bien faire un rapide test. Couru chacun de 5 millions de fois et utilisé le c++11 est le chronomètre pour mesurer le temps qu'il a fallu.

Voici le code:

#include <string>
#include <map>
#include <chrono>
#include <cstdio>
//5 million
#define times 5000000
int main()
{
std::map<std::string, int> foo1, foo2, foo3, foo4, foo5;
std::chrono::steady_clock::time_point timeStart, timeEnd;
int x = 0;
//1) Assignment using array index notation
timeStart = std::chrono::steady_clock::now();
for (x = 0; x <= times; x++)
{
foo1[std::to_string(x)] = 12345;
}
timeEnd = std::chrono::steady_clock::now();
printf("1) took %i milliseconds\n", (unsigned long long)std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd-timeStart).count());
//2) Assignment using member function insert() and STL pair
timeStart = std::chrono::steady_clock::now();
for (x = 0; x <= times; x++)
{
foo2.insert(std::pair<std::string, int>(std::to_string(x), 12345));
}
timeEnd = std::chrono::steady_clock::now();
printf("2) took %i milliseconds\n", (unsigned long long)std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd-timeStart).count());
//3) Assignment using member function insert() and "value_type()"
timeStart = std::chrono::steady_clock::now();
for (x = 0; x <= times; x++)
{
foo3.insert(std::map<std::string, int>::value_type(std::to_string(x), 12345));
}
timeEnd = std::chrono::steady_clock::now();
printf("3) took %i milliseconds\n", (unsigned long long)std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd-timeStart).count());
//4) Assignment using member function insert() and "make_pair()"
timeStart = std::chrono::steady_clock::now();
for (x = 0; x <= times; x++)
{
foo4.insert(std::make_pair(std::to_string(x), 12345));
}
timeEnd = std::chrono::steady_clock::now();
printf("4) took %i milliseconds\n", (unsigned long long)std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd-timeStart).count());
//5) Matthieu M.'s suggestion of C++11's emplace
timeStart = std::chrono::steady_clock::now();
for (x = 0; x <= times; x++)
{
foo5.emplace(std::to_string(x), 12345);
}
timeEnd = std::chrono::steady_clock::now();
printf("5) took %i milliseconds\n", (unsigned long long)std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd-timeStart).count());
return 0;
}

La sortie pour 5 millions d'itérations est:

1) took 23448 milliseconds
2) took 22854 milliseconds
3) took 22372 milliseconds
4) took 22988 milliseconds
5) took 21356 milliseconds

Version de GCC:

g++ (Built by MinGW-builds project) 4.8.0 20121225 (experimental)

Ma machine:

Intel i5-3570k overclocked at 4.6 GHz

EDIT1: Fixe le code et refait le test.

EDIT2: Ajout de Matthieu M. suggestion pour le C++11 est emplace et il est droit, emplace est plus rapide

OriginalL'auteur Edward A