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

Vor einiger Zeit hatte ich eine Diskussion mit einem Kollegen darüber, wie Werte in STL- Maps eingefügt werden . Ich habe es vorgezogen, map[key] = value; weil es sich natürlich anfühlt und klar zu lesen ist, während er es vorgezogen hat map.insert(std::make_pair(key, value))

Ich habe ihn nur gefragt und keiner von uns kann sich an den Grund erinnern, warum Insert besser ist, aber ich bin sicher, dass es nicht nur eine Stilvorliebe war, sondern dass es einen technischen Grund wie Effizienz gab. In der SGI STL-Referenz heißt es einfach: "Genau genommen ist diese Mitgliedsfunktion nicht erforderlich: Sie existiert nur zur Vereinfachung."

Kann mir jemand diesen Grund nennen oder träume ich nur davon, dass es einen gibt?

Wenn du schreibst

map[key] = value;

Es gibt keine Möglichkeit zu sagen, ob Sie ersetzt die valuefür key, oder wenn Sie erstellt eine neue keymit value.

map::insert() wird nur erstellen:

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

Bei den meisten meiner Apps ist es mir normalerweise egal, ob ich sie erstelle oder ersetze, daher verwende ich die leichter lesbaren map[key] = value.

Die beiden haben unterschiedliche Semantiken, wenn es um den Schlüssel geht, der bereits in der Karte vorhanden ist. Sie sind also nicht direkt vergleichbar.

Für die Version operator [] muss der Wert jedoch standardmäßig erstellt und anschließend zugewiesen werden. Wenn dies also teurer ist als die Kopierkonstruktion, ist dies teurer. Manchmal macht die Standardkonstruktion keinen Sinn, und dann ist es unmöglich, die operator [] -Version zu verwenden.

Eine andere Sache zu beachten std::map :

myMap[nonExistingKey]; erstellt einen neuen Eintrag in der Karte, der mit verschlüsselt ist nonExistingKey auf einen Standardwert initialisiert ist.

Das erschreckte mich zum Teufel, als ich es das erste Mal sah (während ich meinen Kopf gegen einen bösen alten Käfer schlug). Hätte es nicht erwartet. Für mich sieht das nach einer Get-Operation aus, und ich habe den "Nebeneffekt" nicht erwartet. Bevorzugen Sie, map.find()wenn Sie von Ihrer Karte kommen.

Wenn der Leistungstreffer des Standardkonstruktors kein Problem darstellt, wählen Sie aus Liebe zu Gott die besser lesbare Version.

:) :)

insert ist aus Sicht der Ausnahmesicherheit besser.

Der Ausdruck map[key] = valuebesteht eigentlich aus zwei Operationen:

1. map[key] - Erstellen eines Kartenelements mit Standardwert.
2. = value - Kopieren des Wertes in dieses Element.

Im zweiten Schritt kann eine Ausnahme auftreten. Infolgedessen wird die Operation nur teilweise ausgeführt (ein neues Element wurde zur Karte hinzugefügt, aber dieses Element wurde nicht mit initialisiert value). Die Situation, in der eine Operation nicht abgeschlossen ist, der Systemstatus jedoch geändert wird, wird als Operation mit "Nebenwirkung" bezeichnet.

insertBetrieb gibt eine starke Garantie, bedeutet, dass es keine Nebenwirkungen hat ( https://en.wikipedia.org/wiki/Exception_safety ). insertist entweder vollständig erledigt oder die Karte bleibt unverändert.

http://www.cplusplus.com/reference/map/map/insert/ :

Wenn ein einzelnes Element eingefügt werden soll, gibt es im Ausnahmefall keine Änderungen im Container (starke Garantie).

Wenn Ihre Anwendung geschwindigkeitskritisch ist, empfehle ich die Verwendung des Operators [], da insgesamt 3 Kopien des Originalobjekts erstellt werden, von denen 2 temporäre Objekte sind und früher oder später als zerstört wurden.

In insert () werden jedoch 4 Kopien des Originalobjekts erstellt, von denen 3 temporäre Objekte (nicht unbedingt "temporäre") sind und zerstört werden.

Dies bedeutet zusätzliche Zeit für: 1. Zuweisung eines Objektspeichers 2. Ein zusätzlicher Konstruktoraufruf 3. Ein zusätzlicher Destruktoraufruf 4. Eine Freigabe des Objektspeichers

Wenn Ihre Objekte groß sind, Konstruktoren typisch sind, Destruktoren viel Ressourcen freisetzen, zählen die obigen Punkte noch mehr. In Bezug auf die Lesbarkeit denke ich, dass beide fair genug sind.

Die gleiche Frage kam mir in den Sinn, aber nicht über die Lesbarkeit, sondern über die Geschwindigkeit. Hier ist ein Beispielcode, durch den ich den Punkt kennengelernt habe, den ich erwähnt habe.

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

In C ++ 11 denke ich, dass der beste Weg, ein Paar in eine STL-Map einzufügen, ist:

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

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

Das Ergebnis ist ein Paar mit:

• Das erste Element (result.first) zeigt auf das eingefügte Paar oder auf das Paar mit diesem Schlüssel, wenn der Schlüssel bereits vorhanden ist.

• Zweites Element (result.second), true, wenn die Einfügung korrekt oder falsch war, ist ein Fehler aufgetreten.

PS: Wenn Sie sich nicht für die Bestellung interessieren, können Sie std :: unordered_map verwenden;)

Vielen Dank!

Ein Problem mit map :: insert () ist, dass es keinen Wert ersetzt, wenn der Schlüssel bereits in der Map vorhanden ist. Ich habe C ++ - Code gesehen, der von Java-Programmierern geschrieben wurde, bei denen erwartet wurde, dass sich insert () genauso verhält wie Map.put () in Java, wo Werte ersetzt werden.

Ein Hinweis ist, dass Sie auch Boost.Assign verwenden können :

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

Hier ist ein weiteres Beispiel zeigt , dass operator[] überschreibt den Wert für den Schlüssel , wenn es vorhanden ist , aber .insert nicht überschreiben Sie den Wert , wenn es vorhanden ist .

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

Dies ist ein eher eingeschränkter Fall, aber nach den Kommentaren, die ich erhalten habe, halte ich es für erwähnenswert.

Ich habe in der Vergangenheit gesehen, dass Leute Karten in Form von verwenden

map< const key, const val> Map;

Um Fällen von versehentlichem Überschreiben von Werten auszuweichen, schreiben Sie dann einige andere Code-Teile ein:

const_cast< T >Map[]=val;

Ihr Grund dafür war, wie ich mich erinnere, dass sie sicher waren, dass sie in diesen bestimmten Codebits keine Kartenwerte überschreiben würden; Fahren Sie daher mit der besser lesbaren Methode fort[] .

Ich hatte noch nie direkte Probleme mit dem Code, der von diesen Leuten geschrieben wurde, aber ich bin bis heute der festen Überzeugung, dass Risiken - so gering sie auch sein mögen - nicht eingegangen werden sollten, wenn sie leicht vermieden werden können.

Verwenden Sie in Fällen, in denen es sich um Kartenwerte handelt, die unbedingt nicht überschrieben werden dürfen insert. Machen Sie keine Ausnahmen nur zur besseren Lesbarkeit.

Die Tatsache, dass die insert()Funktion std :: map den mit dem Schlüssel verknüpften Wert nicht überschreibt, ermöglicht es uns, Objektaufzählungscode wie folgt zu schreiben:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

Es ist ein ziemlich häufiges Problem, wenn wir einige nicht eindeutige Objekte einigen IDs im Bereich 0..N zuordnen müssen. Diese IDs können später beispielsweise in Diagrammalgorithmen verwendet werden. Alternative mit operator[]würde meiner Meinung nach weniger lesbar aussehen:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
}