Die meisten effiziente Möglichkeit, Werte zuzuweisen, Karten

1) kann etwas langsamer sein, als die anderen Methoden, weil std::map::operator[] erste Standard erstellt das Objekt, wenn es nicht bereits vorhanden ist, und gibt dann eine Referenz, die Sie verwenden können operator= auf den gewünschten Wert, d.h. es sind zwei Operationen.

2-4) sollten gleichwertig sein, da map::value_type ist ein typedef auf std::pair für die gleichen Arten, und daher make_pair ist ebenfalls äquivalent. Sollte der compiler behandelt diese identisch.

Beachten Sie auch, dass die Leistung weiter erhöht werden kann, wenn Sie brauchen, um beide zu überprüfen Existenz (z.B. zur Ausführung von speziellen Logik, je nachdem, ob es existiert oder nicht) und dann auch einfügen, indem map::lower_bound zuerst ein Hinweis, wo das element " sein sollte, so map::insert nicht zu suchen haben, das ganze map wieder:

 //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;
 }

Wenn kein Objekt vorhanden ist, an diesem Ort, dann:

std::map::emplace am effizientesten ist. insert ist der zweite (aber sehr nahe). [] ist die am wenigsten effiziente.

[], wenn es kein Objekt gibt, triviale Konstrukte ein. Es ruft dann operator=.

insert macht ein copy-Konstruktor-Aufruf auf der std::pair argument.

Jedoch, im Falle von Karten, die map.insert( make_pair( std::move(key), std::move(value) ) ) wird in der Nähe map.emplace( std::move(key), std::move(value) ).

Wenn es ein Objekt am Ort, dann [] rufen operator=, während insert/emplace wird, löschen Sie das alte Objekt und erstellen Sie eine neue. [] könnte leicht billiger in diesem Fall.

In das Ende, es hängt davon ab, was Ihr operator= vs copy-Konstrukt vs trivial-Konstrukt vs Destruktor Kosten für Ihre Schlüssel und Wert.

Die eigentliche Arbeit suchen, die Dinge in der Baum-Struktur des std::map so nah zu identisch es ist nicht lustig.

Obwohl es hat schon ein paar gute Antworten schon dachte ich, ich könnte genauso gut tun, eine schnelle benchmark. Lief jeweils 5 Millionen mal verwendet c++11 ' s chrono zum Messen der Zeit, die es brauchte.

Hier ist der 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;
}

Den Ausgang für 5 Millionen Iterationen ist:

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

GCC-version:

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

Meine Maschine:

Intel i5-3570k overclocked at 4.6 GHz

EDIT1: Feste der code umgestrickt und der benchmark.

EDIT2: Hinzugefügt Matthieu M. s Vorschlag für C++11 emplace und er hat Recht, emplace ist am schnellsten