Ist es in STL-Maps besser, map :: insert als [] zu verwenden?

Beim schreiben

map[key] = value;

gibt es keine Möglichkeit zu sagen, wenn Sie ersetzt die value für key oder wenn Sie erstellt eine neue key mit value.

map::insert() wird nur:

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
//...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

Für die meisten meiner apps, die ich in der Regel don ' T care wenn ich mich anlegen oder ersetzen, damit ich den leichter zu Lesen map[key] = value.

InformationsquelleAutor der Antwort netjeff

Andere Sache zu beachten, mit std::map:

myMap[nonExistingKey]; erstellen Sie einen neuen Eintrag in die Karte kodiert, um nonExistingKey initialisiert, um einen default-Wert.

Diese Angst die Hölle aus mir, das erste mal ich es sah (während schlug meinen Kopf gegen eine nastly legacy-bug). Hätte nicht erwartet, dass es. Mir, das sieht aus wie eine get-operation, und ich hatte nicht erwartet, dass die "side-Effekt"." Lieber map.find() wenn immer von Ihrer Karte.

InformationsquelleAutor der Antwort Hawkeye Parker

Wenn Ihre Anwendung ist Geschwindigkeit entscheidend ich berate Sie mithilfe der [] - operator, denn es sorgt insgesamt 3 Kopien des ursprünglichen Objekts aus, die 2 sind temporäre Objekte und früher oder später zerstört.

Aber in der insert(), 4 Kopien des original-Objekts erstellt werden, aus denen 3 sind temporäre Objekte( nicht unbedingt "Provisorien") und werden zerstört.

Was bedeutet, dass Sie zusätzliche Zeit für die:
1. Eines objects memory allocation
2. Eine extra-Konstruktor aufrufen
3. Eine zusätzliche Destruktor-Aufruf
4. Eine Objekte-memory-deallocation -

Wenn Ihre Objekte groß sind, Konstruktoren sind typische, Destruktoren tun eine Menge von Ressourcen freigeben, die oben genannten Punkte zählen sogar noch mehr. In Bezug auf die Lesbarkeit, ich denke, beide sind fair genug.

Die gleiche Frage kam mir in den Sinn, nicht aber über Lesbarkeit, sondern die Geschwindigkeit.
Hier ist ein Beispiel-code, durch die ich kam, zu wissen, über den Punkt, den ich erwähnte.

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

InformationsquelleAutor der Antwort Rampal Chaudhary

Jetzt in c++11 ich denke, dass der beste Weg, um fügen Sie ein paar in einer STL-map ist:

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

Den Ergebnis wird ein paar mit:

• Element mit dem Ergebnis.zuerst), weist auf das paar eingefügt oder
  das paar mit diesem Schlüssel, falls der Schlüssel bereits vorhanden ist.

• Zweite element (Ergebnis.Sekunde), true, wenn das einfügen war richtig oder
  falsch es ging etwas schief.

PS: Wenn Sie nicht über die Bestellung, die Sie verwenden können, std::unordered_map 😉

Dank!

InformationsquelleAutor der Antwort GutiMac

Einer Hinweis ist, dass können Sie auch Boost.Zuweisen:

using namespace std;
using namespace boost::assign; //bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

InformationsquelleAutor der Antwort rlbond

Ist eher ein Fall beschränkt, sondern ausgehend von den Kommentaren, die ich erhalten habe finde ich es erwähnenswert.

Ich habe Menschen gesehen, die in der Vergangenheit Verwendung von Karten in der form von

map< const key, const val> Map;

auszuweichen Fällen des zufälligen Wert überschrieben, aber dann gehen Sie vor schreiben-in einigen anderen bits von code:

const_cast< T >Map[]=val;

Ihren Grund, dies zu tun, wie ich mich erinnere, war, denn Sie waren sicher, dass in diesen bestimmte Codezeilen, die Sie waren nicht zu werden, überschreiben Werte anzeigen; daher geht es weiter mit den mehr 'lesbar' Methode [].

Ich habe eigentlich nie hatte keine direkten Probleme aus dem code, der geschrieben wurde, von diesen Leuten, aber ich fühle mich bis heute, dass die Risiken - so klein - sollte nicht eingenommen werden, wenn Sie leicht vermieden werden kann.

In Fällen, In denen Sie den Umgang mit Karte Werte, die müssen absolut nicht überschrieben werden, verwenden Sie insert. Mache keine Ausnahmen, lediglich zur besseren Lesbarkeit.

InformationsquelleAutor der Antwort dk123