Wann sollte ich std :: map :: at verwenden, um das Kartenelement abzurufen

Habe ich gelesen, die anderen Artikel auf dem web und Fragen an stackoverflowaber für mich ist es nicht klar gibt es eine exklusive Fall, wenn es besser ist, zu verwenden std::map::at abrufen map-element.

Laut definitionstd::map::at

Gibt einen Verweis auf das zugeordnete Wert des Elements identifiziert
der Schlüssel k.

Wenn k nicht mit dem Schlüssel von jedem element in dem container, der
die Funktion wirft eine out_of_range Ausnahme.

Für mich nur dann, wenn es Wert ist zu verwenden std::map::at wenn Sie 100% sicher sein, das element mit bestimmten Schlüssel existiert, ansonsten sollten Sie überlegen, die Behandlung von Ausnahmen.

  1. Gibt es irgendeinen Fall, wo std::map::at als die meisten effiziente und elegante Art und Weise zu tun? In welchen Fällen empfehlen die Verwendung von std::map::at ?
  2. Bin ich richtig, dass es besser ist, zu verwenden map::find() wenn es eine Möglichkeit gibt, um nicht-element mit einem solchen Schlüssel? Und map::find() es ist schneller und eleganter Ansatz?
if ( map.find("key") != map.end() )
{
    //found 

} else
{
    //not found
}

p.s

map::operator[] manchmal gefährlich sein kann, denn wenn ein element nicht existiert, dann wird er es fügt.

BEARBEITET: links, die irgendwie im Zusammenhang link 1 link 2 link 3 link 4 link 5 link 6

InformationsquelleAutor der Frage T M | 2015-10-20

  1. 42

    Im Gegensatz zu den meisten bisherigen Antworten hier, beachten Sie, dass es gibt tatsächlich 4 Methoden für das finden eines Elements in einer Karte (ignorieren lower_boundupper_bound und equal_rangedie sind weniger präzise):

    • operator[] existieren nur in nicht-const-version, wie erwähnt, es wird das element anlegen wenn Sie nicht vorhanden ist
    • at() eingeführt, die in C++11 gibt eine Referenz auf das element, wenn es existiert, und wirft andernfalls eine exception
    • find() gibt einen iterator auf das element, wenn es vorhanden ist, oder ein iterator zu map::end() wenn es nicht
    • count() gibt die Anzahl der Elemente, die in einem map ist dies 0 oder 1

    Nun, dass die Semantik ist klar, lassen Sie uns überprüfen, Wann welcher zu benutzen:

    • wenn Sie nur wissen wollen, ob ein element vorhanden ist in der map (oder auch nicht), dann verwenden Sie count().
    • wenn Sie möchten, um Zugriff auf das element, und es wird in der mapdann verwenden Sie at().
    • wenn Sie möchten, um Zugriff auf das element, und weiß nicht, ob es in der map oder nicht, dann verwenden Sie find(); vergessen Sie nicht, um zu überprüfen, dass die entstehende iterator wird nicht gleich das Ergebnis des end().
    • schließlich, wenn Sie wollen, Zugriff auf das element, wenn es vorhanden ist, oder erstellen Sie es (und darauf zugreifen), wenn Sie nicht, verwenden Sie operator[]; wenn Sie nicht mitgehen möchten, die Art default-Konstruktor zu erstellen, dann verwenden Sie entweder insert oder emplace entsprechend

    InformationsquelleAutor der Antwort Matthieu M.

  2. 19

    std::map::at() wirft ein out_of_range Ausnahme, wenn das element nicht gefunden werden konnte. Diese Ausnahme ist eine Art von logic_error Ausnahme, die für mich eine Art synonym von assert() aus der Nutzung Standpunkt: es sollte verwendet werden, um Fehler in der internen Logik des Programms, wie die Verletzung der logischen Voraussetzungen oder Klasse von Invarianten.

    Können Sie auch at() Zugriff auf const-Karten.

    Also, zu Ihren Fragen:

    1. Ich empfehlen at() statt [] beim Zugriff auf const-maps und wenn das element Abwesenheit ist ein Logik Fehler.
    2. Ja, es ist besser map::find() wenn Sie sich nicht sicher, element ist hier: in diesem Fall ist es nicht ein logischer Fehler und damit das werfen und fangen std::logic_error Ausnahme wird nicht sehr elegante Art der Programmierung, auch wenn wir nicht darüber nachdenken Leistung.

    InformationsquelleAutor der Antwort alexeykuzmin0

  3. 10

    Als Sie bemerkte, gibt es drei verschiedene Möglichkeiten, den Zugriff auf Elemente in einer map: at()operator[] und find() (es gibt auch upper_boundlower_bound und equal_rangediese sind aber für kompliziertere Situationen, in denen Sie möglicherweise suchen Sie ein nächsten/vorherigen element etc.)

    So, wenn Sie verwenden sollten, welches wäre das?

    operator[] im Grunde ist "wenn es nicht vorhanden ist, erstellen Sie mit ein default-konstruiertes element zugeordnet". Das bedeutet, dass er nicht werfen (außer in den Ausnahmefällen, wenn die Speicherzuordnung wirft oder einer der Schlüssel oder Wert-Konstruktoren werfen), und man bekommt eine Referenz auf das element, das Sie suchten - entweder die bestehende oder die neu erstellt werden.

    at() wirft, wenn es kein element für diesen Schlüssel. Da sollten Sie nicht verwenden exceptions für den normalen Programmfluss, mit at() sagt: "ich bin sicher, dass es ein solches element." Aber mit dem zusätzlichen Vorteil, dass Sie eine Ausnahme (und nicht zu undefiniertem Verhalten), wenn Sie falsch sind. Verwenden Sie nicht dieses, wenn Sie nicht positiv ist, dass das element vorhanden ist.

    find() sagt: "es kann nicht sein, ein solches element, mal sehen..." und bietet Ihnen die Möglichkeit, zu reagieren, beide Fälle unterschiedlich. Es ist daher der allgemeinere Ansatz.

    InformationsquelleAutor der Antwort Arne Mertz

  4. 5

    Alle 3 findoperator[] und at nützlich sind.

    • find ist gut, wenn Sie nicht möchten, dass versehentlich Elemente einfügen, sondern nur handeln, wenn Sie vorhanden sind.

    • at ist gut, wenn Sie erwarten, dass etwas auf eine Karte, und Sie würden eine exception werfen, wenn es nicht sowieso. Es können auch auf const Karten in einer knapperen Angelegenheit als find (wo Sie nicht verwenden können op[])

    • op[] ist gut, wenn Sie wollen einfügen, um ein Standard-element, wie für die Wort-zähl-Programm, das setzt eine int - 0 für jedes Wort begegnet zum ersten mal (mit dem idiom words[word]++;).

    InformationsquelleAutor der Antwort Bartek Banachewicz

  5. 3

    Diese hängt davon ab, was die Anforderungen sind für diese Funktion und wie sind Sie strukturieren das Projekt. Wenn Sie werden sollte ein Objekt zurückgeben, und Sie können nicht, weil es nicht gefunden wurde, dann ist es lässt Sie mit zwei Optionen auf, wie damit umzugehen ist. Sie könnte durch eine Ausnahme-oder Sie zurückgeben könnte, irgendeine Art von sentinel das bedeutet, dass nichts gefunden wurde. Wenn Sie möchten, eine exception werfen, dann verwenden Sie at() als die exception wird geworfen, für Sie. Wenn Sie nicht möchten, dass eine exception werfen, dann verwenden Sie find() so dass Sie nicht haben, um mit der Handhabung einer Ausnahme nur um wieder eine sentinel-Objekt.

    InformationsquelleAutor der Antwort NathanOliver

  6. 3

    Ich denke, es hängt von Ihrem Anwendungsfall. Der Rückgabetyp std::map::at() ist ein lvalue-Referenz auf den Wert des gefundenen Elements, während std::map::find() gibt einen iterator. Sie könnten es vorziehen, 

    return myMap.at("asdf"s) + 42;

    in äußerungen über die aufwändigere

    return myMap.find("asdf"s)->second + 42;

    Wann immer Sie das Ergebnis verwenden von std::map::at() in einem Ausdruck, die Sie erwarten, dass das element vorhanden ist, und betrachten ein element fehlt, als ein Fehler. So eine Ausnahme ist eine gute Wahl, damit umzugehen.

    InformationsquelleAutor der Antwort cdonat

  7. 2

    Ich denke, der Unterschied ist Semantik.

    std::map::at() aussieht wie das auf meiner Maschine:

    mapped_type&
at(const key_type& __k)
{
    iterator __i = lower_bound(__k);
    if (__i == end() || key_comp()(__k, (*__i).first))
        __throw_out_of_range(__N("map::at"));
    return (*__i).second;
}

    Wie Sie sehen können, verwendet es lower_bounddann prüft end() vergleicht Schlüssel, und wirft die Ausnahme, wo nötig.

    find() sieht wie folgt aus:

    iterator
find(const key_type& __x)
{ return _M_t.find(__x); }

    wo _M_t ist ein rot-schwarz-Baum, der speichert die eigentlichen Daten. Offensichtlich, die beide die Funktion haben, die gleichen (logarithmischen) Komplexität. Wenn Sie find() + check für end() Sie tun fast das gleiche, was at tut. Ich würde sagen, der semantische Unterschied ist:

    • verwenden at() wenn Sie brauchen, ein element an einem bestimmten Ort, und Sie davon ausgehen, dass es da ist. In diesem Fall wird die situation der das element fehlt, aus dem gewünschten Ort ist außergewöhnlich, so at() wirft eine Ausnahme.
    • verwenden find() wenn Sie brauchen, um zu finden das element in der Karte. In diesem Fall ist die situation, wenn das element nicht vorhanden ist, ist normal. Beachten Sie auch, dass find() gibt einen iterator, die Sie verwenden können, für andere Zwecke als nur die Beschaffung ist es Wert.

    InformationsquelleAutor der Antwort SingerOfTheFall

  8. 2

    map::at() liefert einen l-Wert-Referenz, und wenn Sie die Rückgabe durch Referenz verwenden, können Sie alle verfügbaren Vorteile, wie z.B. die Verkettung von Methoden.

    Beispiel:

      map<int,typ> table;
  table[98]=a;
  table[99]=b;

  table.at(98)=table.at(99);

    operator[] auch gibt den zugeordneten Wert durch Referenz, aber Sie können fügen Sie einen Wert, wenn der gesuchte Schlüssel nicht gefunden wird, in dem Fall container Größe um eins erhöht.

    Dies erfordert, dass Sie besonders vorsichtig sein, da Sie zu kümmern iterator-Invalidierung.

    Bin ich richtig, dass es besser ist die Verwendung von map::find (), wenn es eine
    Möglichkeit nicht haben element mit einem solchen Schlüssel? Und map::find() ist es
    schneller und eleganter Ansatz?

    Ja, semantisch macht es Sinn, find (), wenn Sie nicht sicher sind, von der Existenz element.Macht den code leichter zu verstehen, auch für Anfänger.

    Als für die Zeit, die Effizienz, die Karte ist in der Regel umgesetzt werden, da ein RB-Baum/eine ausgewogene binären Suchbaum und damit die Komplexität ist O(logN) für die find().

    C++ Spec:

    T& operator[](const key_type& x);

    Effekte: Wenn es keinen Schlüssel entspricht x in der Karte, Beilagen value_type(x, T()) in die Karte.
    Erfordert: key_type werden CopyInsertable und mapped_type werden
    DefaultInsertable in *diesem. Rückgabe: Eine Referenz auf das
    mapped_type entsprechend x in *diesem. 4 Komplexität: Logarithmisch.

    T& at(const key_type& x);

    const T& at(const key_type& x) const;
    Rückgabe: Eine Referenz auf das mapped_type entsprechend x in *diesem.
    Würfe: Ein exception-Objekt vom Typ out_of_range wenn kein solches element vorhanden ist.
    Komplexität: Logarithmisch.

    InformationsquelleAutor der Antwort basav

Schreibe einen Kommentar