So verwenden Sie Karten in C ++

C ++ - Karte ist eine Listendatenstruktur mit Schlüssel-/Wertpaaren. Eine Datenstruktur hat Mitgliedsfunktionen. In C ++ gibt es eine Karte, und es gibt eine nicht ordnungsgemäße_map. Die Karte ist eigentlich eine bestellte Karte. Die Reihenfolge für die Karte kann durch Schlüssel aufsteigen oder absteigen. Der Standardwert ist aufsteigende Reihenfolge nach Schlüssel. Die Funktionen für bestellte Karte und nicht ordnungsgemäße Karte sind so viele, dass nur die für die Karte (i.e., Bestellte Karte) wird in diesem Artikel berücksichtigt.

Die Funktionen der Karte können in Konstruktion, Elementzugriff, Kapazität, Iteratoren, Modifikatoren, Beobachter, Operationen und spezialisierte Algorithmen eingeteilt werden. Es kommt auch vor, dass die Kartenfunktionen viele sind. Daher werden nur die grundlegenden Funktionen in diesen Kategorien erklärt.

Ein Beispiel für eine Liste von Schlüssel-/Wertpaaren ist die folgende Liste der Früchte und deren reifen Hautfarben:

Blackberry => Dunkelblau-Black
Mango => Gelb
Passionsfrucht => lila
Plum => lila
Banane => Gelb

Die Saiten links von der Liste bilden die Schlüssel; Diejenigen, die auf der richtigen Werte sind. Schlüssel-/Wertpaare dürfen nicht unbedingt von String/String sein. Es kann aus int/string, string/float, int/float usw. sein. In einer C ++ - Karte ist ein Schlüssel-/Wertpaar ein Element, und solche Elemente bilden die Datenstrukturliste. Eine Kartendatenstruktur bietet ein schnelles Abrufen von Daten basierend auf Tasten. Die Schlüssel sind einzigartig und die Kartenstruktur ist viel zu eins. Dies bedeutet, dass die Werte Duplikate haben können, aber die Schlüssel können nicht.

Um die Kartenbibliothek in einem C ++ - Programm zu verwenden, sollte das Programm mit so etwas wie folgt beginnen:

#enthalten
#enthalten
Verwenden von Namespace STD;

Wenn Saiten Teil der Karte sind, ist die Verwendung von #include anstelle von ratsam. In diesem Artikel wird erläutert, wie Sie eine C ++ - Karte verwenden.

Artikelinhalt

• Konstruktion/Zerstörung
• Konstruktions- und Anpassungspaare
• Anzeigen (Druck-) Karteninhalt
• Elementzugriff
• Kapazität
• Iteratoren
• Modifikatoren
• Aufsteigend oder absteigender Ordnung
• Operationen
• Spezialalgorithmen
• Abschluss

Konstruktion/Zerstörung

Eine Karte ist ein assoziativer Container, der aus einer Kartenklasse konstruiert werden muss.

Karte (initializer_list, const compare & = compare (), const allocator & = allocator ())

Die folgende Anweisung erstellt eine Karte für die obige Liste durch Initialisierung:

Karte MP "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passionsfrucht", "lila", "Plum", "lila", "Banana" , "Gelb";

Beachten Sie, wie jedes Paar abgegrenzt wurde.

a = il

Die folgende Initialisierungskonstruktion verwendet den Zuordnungsoperator:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila", "Plum", "lila", "Banana ", "Gelb";

Eine leere Karte kann mit dem linken Ausdruck erstellt werden, und dann die Elemente später hinzugefügt - siehe unten.

Zerstörung
Um eine Karte zu zerstören, lassen Sie sie einfach aus dem Zielfernrohr gehen.

Konstruktions- und Anpassungspaare

Für die obige Karte besteht ein Paar aus einem String -Schlüssel und einem String -Wert. Ein Paarelement kann unabhängig von der Karte konstruiert werden. Das folgende Codesegment erstellt ein leeres Paarobjekt aus einer Paarklasse und weist dann einen Schlüssel und einen Wert zu:

Paar PR;
pr.First = "Blackberry";
pr.Second = "Dark Blue-Black";

Der Name für die Schlüsseleigenschaft ist zuerst und der Name für die Werteigenschaft ist zweiter Stelle. Der folgende Code erstellt eine leere Karte und fügt zwei Paare mit der Map -Einfügungselementfunktion ein.

Karte MP;
Paar PR0;
PR0.First = "Blackberry";
PR0.Second = "Dark Blue-Black";
Paar PR1;
PR1.first = "mango";
PR1.zweite = "gelb";
MP.Insert (PR0);
MP.Insert (PR1);

Anzeigen (Druck-) Karteninhalt

Der folgende Code verwendet einen Iterator (IT), der aus dem ersten Element der Karte entwickelt wurde, um die Schlüssel-/Wertpaare an der Konsole anzuzeigen:

Karte mp = "Plum", "lila", "mango", "gelb", "blackberry", "dunkelblau-schwarz", "Passionsfrucht", "lila", " Banane "," gelb ";
für (map :: iterator it = mp.Start(); Es!= MP.Ende(); ++ es)
Cout Blackberry => Dunkelblau-Black
Mango => Gelb
Passionsfrucht => lila
Plum => lila

=> hat hier keine C ++ - Bedeutung. Es wird nur verwendet, um den Schlüssel von seinem entsprechenden Wert an der Anzeige zu trennen. Um den Wert einer Eigenschaft eines Zeigers (Iterator) zu erhalten, verwenden Sie -> zwischen dem Zeiger (Iterator) und dem Eigenschaftsnamen. Also, -> hat Bedeutung in C++.

Beachten Sie, dass die Liste in aufsteigender Reihenfolge der Schlüssel angezeigt wurde, obwohl die Elemente nicht codiert wurden.

Auf die Schlüssel-/Wertpaare kann weiterhin mit dem Schema für die Element-in-in-Liste zugegriffen werden. Das folgende Codesegment zeigt dies:

Karte mp = "Plum", "lila", "mango", "gelb", "blackberry", "dunkelblau-schwarz", "Passionsfrucht", "lila", " Banane "," gelb ";
für (Paar Elem: MP)
Cout << elem.first < " << elem.second < yellow
Blackberry => Dunkelblau-Black
Mango => Gelb
Passionsfrucht => lila
Plum => lila

Wie früher. Beachten Sie, dass Elem hier ein Objektname und kein Zeiger ist (noch Iterator). Es folgt also ein Punkt und nicht ->, um auf die Eigenschaft zuzugreifen.

Elementzugriff

T & Operator [] (KEY_TYPE && x)

Ein Element, das nicht in der Karte zuvor vorliegt. Der Wert eines Elements, das sich bereits auf der Karte befindet, kann mit seinem Schlüssel durch den [] Operator gelesen werden. Das folgende Programm zeigt diese:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte MP;
MP ["Plum"] = "lila";
MP ["Passionsfrucht"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
Cout<Cout<Cout<Rückkehr 0;

Die Ausgabe ist:

lila
lila
dunkelblau-schwarz

const t & at (const key_type & x) const

Wenn die Karte konstant erklärt wird, können die Werte der Schlüssel nicht geändert werden. Diese Mitgliedsfunktion kann jedoch verwendet werden, um die Werte der Schlüssel zu lesen. Der folgende Code zeigt dies:

const map mp "plum", "lila", "mango", "gelb", "blackberry", "dunkelblau-schwarz";
Cout<Cout<Cout<

Die Ausgabe ist:

lila
Gelb
dunkelblau-schwarz

Kapazität

size_type size () const noexcept

Die Länge einer Karte kann unter Verwendung der Member -Funktion der Größe () bestimmt werden, wie der folgende Code zeigt:

const map mp "plum", "lila", "mango", "gelb", "blackberry", "dunkelblau-schwarz";
Cout<

Die Ausgabe ist 3.

[[nodiscard]] bool leer () const noexcept

Diese Mitgliedsfunktion gibt true zurück, wenn die Karte leer ist und ansonsten falsch ist. Beispiel:

const map mp;
Cout<

Die Ausgabe ist 1 für True. Es wäre 0 für False gewesen (sonst).

Iteratoren

Iterator begin () noexcept

Dies gibt einen bidirektionalen Iterator zurück, der auf das erste Element der Karte zeigt. Der Wert des Elements (Paar) zeigt an, kann geändert werden. Beispielcode:

Karte MP "Plum", "lila", "Mango", "Yellow", "Blackberry", "Dark Blue-Black";
Karte :: Iterator It;
für (it = mp.Start(); Es!= MP.Ende(); es ++)
Cout
Coutfür (map :: iterator it = mp.Start(); Es!= MP.Ende(); es ++)
Cout Mango => Gelb
Plum => lila
Blackberry => Dunkelblau-Black
Mango => Weiß
Plum => lila

Der Wert für das zweite Schlüssel-/Wertpaar wurde geändert. Beachten Sie die Verwendung des Ende () Iterators.

Reverse_iterator rbergin () noexcept

Dies gibt einen bidirektionalen Reverse -Iterator zurück, der auf das letzte Element der Karte zeigt. Der Wert des Elements, auf das es hinweist, kann geändert werden. Der folgende Code erzeugt das gleiche Ergebnis wie das oben oben:

Karte MP "Plum", "lila", "Mango", "Yellow", "Blackberry", "Dark Blue-Black";
Karte :: Reverse_iterator it;
für (it = mp.rbegin (); Es!= MP.zerreißen(); es ++)
Cout
Coutfür (map :: Reverse_iterator it = mp.rbegin (); Es!= MP.zerreißen(); es ++)
Cout Mango => Gelb
Blackberry => Dunkelblau-Black
Plum => lila
Mango => Weiß
Blackberry => Dunkelblau-Black

Der gleiche Wert für das zweite Schlüssel-/Wertpaar wurde geändert.

Modifikatoren

Da die Karte nach dem Einfügen immer von Schlüsseln angeordnet (geordnet) wird, spielt es keine Rolle, ob das Einfügen vom Programmierer am Anfang, innerhalb oder am Ende der Karte gezielt wird. Aufsteigerer Reihenfolge nach Schlüssel ist das Standardgebnis ist.

Das Ändern der Karte befasst sich mit dem Einfügen, Einlagern, Extrahieren, Löschen und Löschen. Einfügen und Einlösen sind ähnlich, aber die Emplacing ist besser.

Empace

Paar a_uniq.Emplace (Args)

Diese Mitgliedsfunktion fügt die Literale des Schlüssel-/Wertespaars ein, die durch Komma ohne die lockigen Klammern getrennt sind, wie im folgenden Code gezeigt:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila";
Paar PR = MP.Emplace ("Banane", "Gelb");
für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout<Cout Blackberry => Dunkelblau-Black
Mango => Gelb
Passionsfrucht => lila
Banane => 1

Die EMPLACE (Args) -Mitgliedfunktion gibt ein Paar zurück, das dem eingefügten Element entspricht. Der Schlüssel dieses Rückkehrpaares ist ein Iterator, der auf das eingefügte Element zeigt. Der Wert dieses Rückgabepaares ist wahr (1) Wenn ein Insertion stattgefunden hat und falsch (0), wenn keine Einfügung stattgefunden hat.

Beachten Sie die Art und Weise, wie der Rückgabetyp für Empla (Args) codiert wurde. Außerdem wurde das Rückgabepaar nicht verwendet, um den Schlüssel/den Wert des eingefügten Kartenpaares in der letzten Ausgabeanweisung zu erhalten. Hier gibt es zwei Arten von Paaren: das Paar für die Karte und das Rückkehrpaar. Sie sind nicht kompatibel. Wenn der Schlüssel bereits in der Karte existierte, würde der zurückgegebene Iterator auf den existierenden Schlüssel verweisen. Dann wäre der Boolesche Wert falsch.

Einfügen

Paar insert (value_type && x)

Diese Mitgliedsfunktion fügt die Literale des Schlüssel-/Wertespaars ein, das durch Komma getrennt ist, mit den Curly -Klammern, wie im folgenden Code gezeigt:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila";
Paar PR = MP.Insert ("Banana", "Yellow");
für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout<Cout Blackberry => Dunkelblau-Black
Mango => Gelb
Passionsfrucht => lila
Banane => 1

Die Erklärung ist ähnlich wie der obige Fall für Emplace (Args).

Paar insert (const value_type & x)

Die Kennung eines Paares kann als Argument für die Funktion Insert () verwendet werden. Illustration:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila";
Paar PR;
pr.First = "Banane";
pr.zweite = "gelb";
Paar ib = mp.Insert (PR);
für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout<Cout Blackberry => Dunkelblau-Black
Mango => Gelb
Passionsfrucht => lila
Banane => 1

Die Erklärung ähnelt dem obigen Fall.

void Insert (Initializer_List)

Eine ganze Liste kann eingefügt werden. Unmittelbar nach dem Einfügen gibt es eine Umlagerung (in aufsteigender Reihenfolge). Illustration:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila";
MP.insert ("Watermelon", "grün", "Grape", "Pink", "Apricot", "Orange");
für (Auto Elem: MP)
Cout << elem.first < " << elem.second < orange
Blackberry => Dunkelblau-Black
Traube => rosa
Mango => Gelb
Passionsfrucht => lila
Wassermelone => grün

Hinweis: Auf der Karte sollte bereits kein Schlüssel der Liste vorhanden sein.

Void Insert (InputIterator zuerst, InputIterator zuletzt)

Ein Bereich [i, j) von einer anderen Karte kann eingefügt werden. Hier sind ich und j Iteratoren. Illustration:

Karte mp1 = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya",, "orange";
Karte :: Iterator ITB = MP1.Start();
ITB ++;
Karte :: Iterator ite = mp1.Ende();
ite--; ite--;
Karte mp2 = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passionsfrucht", "lila";
MP2.Insert (ITB, ITE);
für (Auto Elem: MP2)
Cout << elem.first < " << elem.second < dark blue-black
Traube => rosa
Mango => Gelb
Papaya => Orange
Passionsfrucht => lila

Beachten Sie, dass das Element, das J der ersten Karte entspricht. Dies entspricht der Notation, [i, j).

Löschen

size_type erase (const key_type & x)

Löscht das von Schlüssel identifizierte Element und gibt die Anzahl der gelöschten Elemente zurück (sollte 1 im Fall von Nicht-Multimap sein). Illustration:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila";
int n = mp.löschen ("Mango");
Cout<für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout <Cout<Passionsfrucht => lila
2

Das gelöschte Element wird so weit entfernt, was der Benutzer betrifft. Die Anzahl der Elemente wird also reduziert.

Iterator -Löschen (const_iteratorposition)

Das Löschen kann mit einem Iterator erfolgen. Gibt einen Iterator zurück, der nach dem Lösch auf das Element zeigt. Illustration:

Karte mp = "Blackberry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "lila";
Karte :: iterator it = MP.Start();
es ++;
Karte :: Iterator iter = MP.löschen (es);
Cout für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout <Cout<Blackberry => Dunkelblau-Black
Passionsfrucht => lila
2

Iterator -Löschen (const_iterator zuerst, const_iterator zuletzt)

Dadurch werden Iteratoren verwendet, um einen Bereich von der geordneten Karte zu löschen. Es gibt einen Iterator zurück, der nach dem gelöschten Bereich auf das Element zeigt. Illustration:

Karte mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya",, "orange";
für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout <Karte :: Iterator itb = MP.Start();
ITB ++;
Karte :: iterator ite = mp.Ende();
ite--; ite--;
Karte :: Iterator iter = MP.löschen (ITB, ITE);
Cout für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout <Cout<Traube => rosa
Papaya => Orange
Pfirsich => Dunkelgelb
Erdbeere => Rot
Pfirsich => Dunkelgelb
apricot => orange
Pfirsich => Dunkelgelb
Erdbeere => Rot
3

Die Bestellung des ursprünglichen Inhalts der Karte wird zunächst bei der Ausgabe angezeigt, damit der gelöschte Bereich geschätzt werden kann. Beachten Sie, dass das Element, auf das der zweite Argument -Iterator hingewiesen wurde, nicht gelöscht wird.

Klar

void clear () noexcept

Löscht alle Elemente der Karte und macht die Größe der Karte, Null. Beispiel:

Karte mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
MP.klar();
Cout<

Die Ausgabe ist 0.

Extraktion
Dies befasst sich mit node_type - siehe später.

Verschmelzung
Wenn zwei Karten zusammengeführt werden, vermischen sich die Elemente in Ordnung (aufsteigend); Kein Schlüssel-/Wertpaar ist getrennt.

void a.zusammenführen (A2)

Ein Element in A2 mit demselben Schlüssel in a wird nicht extrahiert. Dies befasst sich mit node_type - siehe später.

Aufsteigend oder absteigender Ordnung

Standardmäßig wird eine Karte kurz nach der Erstellung durch Schlüssel aufsteigern. Es kann absteigend gemacht werden. In den Vorlagenwinkelklammern hat der dritte Parameter den Standardtyp weniger. Und so muss es nicht getippt werden. Um die Karte nach dem Schlüssel abfällt, muss größer verwendet werden, wie im folgenden Code:

Karte mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
für (Auto Elem: MP)
Cout << elem.first < " << elem.second < red
Traube => rosa
apricot => orange

Sobald eine Karte erstellt wird, wird sie aufsteigend oder absteigend bestellt (standardmäßig aufsteigt). Weniger oder größer wird als Vergleichsobjekt bekannt.

Operationen

Iterator Find (const key_type & x)

Gibt den Iterator des Elements zurück, dessen Schlüssel das Argument ist zu finden (). Illustration:

Karte mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
Karte :: iterator it = MP.Find ("Traube");
Cout

Iterator locker_bound (const key_type & x)

In einer Karte werden die Elemente in standardmäßiger Reihenfolge nach Schlüssel in aufsteigender Reihenfolge angeordnet. Wenn der Programmierer den Iterator kennen will, der auf das Element hinweist, das nicht niedriger ist als das eines bestimmten Schlüssels, muss er diese Mitgliedsfunktion verwenden. Illustration:

Karte mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya",, "orange";
für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout <Karte :: iterator it = MP.Lower_bound ("Papaya");
Cout Traube => rosa
Papaya => Orange
Pfirsich => Dunkelgelb
Erdbeere => Rot
Papaya => Orange

In dieser Situation verweist der Iterator auf das Schlüsselelement. Wenn der Schlüssel nicht gefunden wird, gibt die Funktion einen Iterator zurück, der kurz nach dem Ende der Karte zeigt. In dieser Situation ist es zyklisch und wäre das erste Element der Karte.

Iterator Upper_bound (const key_type & x)

Wenn der Programmierer den Iterator kennenlernen möchte, der auf das Element mit Key größer als k zeigt, muss er diese Mitgliedsfunktion verwenden. Illustration:

Karte mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya",, "orange";
für (Auto Elem: MP)
Cout << elem.first < " << elem.second << endl;
Cout <Karte :: iterator it = MP.ober_bound ("Papaya");
Cout Traube => rosa
Papaya => Orange
Pfirsich => Dunkelgelb
Erdbeere => Rot
Pfirsich => Dunkelgelb

Ein Iterator, der kurz nach der Rückgabe des Schlüsselelements auf das Element zeigt. Wenn der Schlüssel für das letzte Element ist, sollte eine Ausnahme geworfen werden. Wenn der Schlüssel nicht vorhanden ist, ist das Ergebnis unzuverlässig.

Spezialalgorithmen

Das Folgende ist die Syntax einer speziellen Algorithmusfunktion:

Vorlage
Hohlraumtausch (Map & X, Map & Y) noexcept (noexcept (x.Swap (y)));

Die folgende Syntax kann stattdessen verwendet werden:

Hohlraumtausch (Karte &)

Dies tauscht die Paare der beiden Karten aus, die nicht gleich groß sind. Beispiel:

Karte MP1 = "Plum", "lila", "Mango", "Yellow", "Blackberry", "Dark Blue-Black", "Passionsfrucht", "lila", " Banane "," gelb ";
Karte mp2 = "Watermelon", "Green", "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", ",", ",", ",", ",", ",", ",", ",", ",", ",", "," Dunkelgelb ", " Papaya "," orange ";
MP1.Swap (MP2);
Cout << "New mp1:" << endl;
für (Auto Elem: MP1)
Cout << elem.first < " << elem.second << endl;
Cout<Cout << "New mp2:" << endl;
für (Auto Elem: MP2)
Cout << elem.first < " << elem.second << endl;

Abschluss

Eine Karte besteht aus Schlüssel-/Wertpaaren. Es wird von Schlüssel bestellt, entweder aufsteigend oder absteigend. Die Standardreihenfolge steigt auf. Grundlegende Elementfunktionen für die Karte: map (), operator [], at (), size (), leer (), begin (), end (), rbergin (), rend (), emplace (), Insert () , erase (), clear (), find (), Lower_bound (), ober_bound () und a1swap (a2).