C ++ Kartenfunktionen

„Karten handelt. Jeder Schlüssel in einem Schlüsselwertpaar, das alle Komponenten einer Karte enthält, ist unterschiedlich. Tasten werden zur Bestellung verwendet, aber jeder Schlüssel hat eine Reihe von verwandten Werten. Daten können bei Bedarf hinzugefügt und entfernt werden. In der C ++ - Programmiersprache halten Karten Elemente, die durch Kombination eines Schlüsselwerts und eines definierten Werts erstellt wurden.

Für zwei primäre Zwecke können C ++ - Programmierer die Kartenstruktur nützlich finden. Erstens ermöglicht eine Karte durch die Verwendung des Schlüssels eine schnelle und einfache Zugänglichkeit zum Wert. Das Erstellen eines Index- oder Zeigertyps kann von diesem Attribut profitieren. Ein Schlüssel muss im gesamten integrierten Datenrahmen eindeutig sein, das die Karte bietet. Dies verhindert die Duplizierung von Daten; Daher ist es ein weiterer Vorteil der Verwendung der Karte.

Wenn Sie beispielsweise eine Handels -App erstellen und Asset -Werte mit dem Ticker -Zeichen aufbewahren müssen, ist eine Karte aufgrund dieser beiden Vorteile ein nützlicher Ansatz. Eine Karte wäre eine effiziente Methode, um das vorhandene Wetter in vielen Städten auf der ganzen Welt bereitzustellen und zu überprüfen, wenn wir eine Wetter -App entwickelt hätten. Wir werden wahrscheinlich eine Karte auf einem Online -Marktplatz verwenden, um Produkte nach Marken oder Kategorien zu finden.”

Wann vermeiden Sie die Verwendung einer C ++ - Karte?

Die Kartenfunktion von C ++ ist geeignet, um Werte nach Schlüssel effizient zu lokalisieren. Das Finden von Elementen der Karte durch die Verwendung einer Ganzzahl besteht jedoch darin, die vollständige Karte einmal zu durchqueren. Durch eine Karte durch eine Karte kann es zeitaufwändig werden, wenn eine Karte an Größe wächst, wenn wir in der Lage sein möchten, Werte darin zu finden. Eine bidirektionale Karte wird vom Boost-Modul bereitgestellt, was es effektiver macht, wenn wir die Daten häufig abrufen. Da das Standard -C ++ - Modul dieses Datenmodell nicht enthält, muss der Benutzer entweder die Boost -Bibliothek auf jedem Computer erwerben, auf dem das Programm ausgeführt wird.

Eine Karte ist möglicherweise nicht die beste Struktur, wenn wir erkennen, dass wir eine Karte nach Element in einer einfachen Anwendung finden müssen. Verwenden Sie ein C ++ - Array, ein Puffer, ein Stapel oder einen anderen Datentyp, der die Anwendung erleichtert und effektiver ist.

Lassen Sie uns die Arbeit von Kartenfunktionen in C erörtern++.

Beispiel Nr. 1

Wir werden den Code in dieser Instanz ausführen, um zu zeigen, wie Kartenfunktionen implementiert werden können. Wir können die Komponenten der Karte iterieren. Dazu müssen wir nur einen Iterator konstruieren und ihn dann verwenden.

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

Karte Aufgabe1;
Aufgabe1.Einfügen (Paar(2, 60));
Aufgabe1.Einfügen (Paar(4, 80));
Aufgabe1.Einfügen (Paar(6, 70));
Aufgabe1.Einfügen (Paar(8, 90));
Aufgabe1.Einfügen (Paar(10, 50));
Aufgabe1.Einfügen (Paar(12, 80));
Zuordnung1 [14] = 40;
Karte:: Iterator itr;
Cout << "\nThe map of the assignment1 is : \n";
Cout << "\tKEY\tELEMENT\n";
für (itr = ordnungen1.Start(); itr != Zuordnung1.Ende(); ++ itr)
Cout << '\t' << itr->Erste << '\t' << itr->zweite
<< '\n';

Cout << endl;
Karte Zuweisung2 (Zuordnung1.begin (), Zuordnung1.Ende());
Cout << "\nThe map of the assignment2 after"
<< " assign from assignment1 is : \n";
Cout << "\tKEY\tELEMENT\n";
für (itr = ordnungen2.Start(); itr != Zuordnung2.Ende(); ++ itr)
Cout << '\t' << itr->Erste << '\t' << itr->zweite
<< '\n';

Cout << endl;

Hier integrieren wir die erforderlichen Header -Dateien. und zu Beginn des Codes. Jetzt berufen wir die main () -Funktion. Wir werden den MAP -Befehl verwenden. Innerhalb dieses Befehls initialisieren wir zwei Ganzzahlen. Jetzt müssen wir verschiedene zufällige Werte von Elementen einfügen. Also haben wir die Funktion Insert () verwendet.

Das Argument „Paar“ wird zwei ganze Zahlen haben. Wir geben die Werte von 6 verschiedenen Zuordnungen an. Jetzt müssen wir eine andere Methode zur Einführung des Wertes in einer Karte verwenden. Dann drucken wir die Kartenzuweisung mit dem Befehl map verwenden. Zusammen mit diesem verwenden wir einen Iterator. Die Anweisung „Cout“ wird verwendet, um die Zeile zu drucken. Dann wird die Anweisung "Cout" verwendet, um die Schlüssel und Elemente anzuzeigen. Dann machen wir einen Wert des Wertes von „ITR“. Als nächstes werden wir die Anweisung "Cout" verwenden. Wir haben einen Zeiger erstellt, der auf den Iterator verweist. Wir werden den Term "Endl" verwenden, um in der nächsten Zeile eine Codierung durchzuführen.

Jetzt werden wir die Elemente von Zuweisung1 zu Auftrag2 zuweisen2. Wir werden den MAP -Befehl wieder verwenden. Gleichzeitig haben wir die Funktionszuweisung von begin () und end () verwendet1. Diese Funktionen werden verwendet, um die Werte von Zuordnung1 zu starten und zu beenden1. Jetzt werden wir alle Elemente der benötigten Karte demonstrieren. Die Anweisung "Cout" wird angewendet, um die Zeile "Die Karte von Zuweisung2 nach Zuweisung von Zuweisung1 zu drucken". Dann wird „Cout“ verwendet, um die Schlüssel und Elemente zu zeigen.

Noch einmal wenden wir die „für“ -Schloop an. Wir müssen den Zustand befriedigen. Dann machen wir im Iterator ein Inkrement. Wir werden den Zeiger der ersten und zweiten Elemente der Zuordnung erstellen1. Um den Code aus der neuen Zeile aus zu starten, verwenden wir "Endl". Jetzt entfernen wir alle Elemente bis zum Element mit dem Schlüsselwert "3" in der Zuordnung1 mit dem Schlüsselwert "3".

Cout << "\nassignment2 after eliminating the "
"Elemente mit dem Schlüsselwert von weniger als 3: \ n";
Cout << "\tKEY\tELEMENT\n";
Aufgabe2.löschen (Zuordnung2.begin (), Zuordnung2.finde (3));
für (itr = ordnungen2.Start(); itr != Zuordnung2.Ende(); ++ itr)
Cout << '\t' << itr->Erste << '\t' << itr->zweite
<< '\n';

int n;
n = Zuordnung2.Löschen (4);
Cout << "\nassignment2.erase(4) : ";
Cout << n << " removed \n";
Cout << "\tKEY\tELEMENT\n";
für (itr = ordnungen2.Start(); itr != Zuordnung2.Ende(); ++ itr)
Cout << '\t' << itr->Erste << '\t' << itr->zweite
<< '\n';

Cout << endl;
Cout << "assignment1.lower_bound(10) : "
<< "\tKEY = ";
Cout << assignment1.lower_bound(10)->Erste << '\t';
Cout << "\tELEMENT = " << assignment1.lower_bound(10)->zweite
<< endl;
Cout << "assignment1.upper_bound(10) : "
<< "\tKEY = ";
Cout << assignment1.upper_bound(10)->Erste << '\t';
Cout << "\tELEMENT = " << assig>Nment1.Upper_bound (10)-> Sekunde
<< endl;
Rückkehr 0;

Die Anweisung „Cout“ wird verwendet, um die Anweisung „Zuweisung2 nach der Beseitigung der Elemente mit dem Schlüsselwert von weniger als 3“ zu drucken. Die Anweisung "Cout" druckt auch die Schlüssel und deren Werte aus. Wir haben die Funktion erase () angewendet. Hier haben wir die Methode begin () verwendet. Aufgrund dieser Funktion beginnt es die Schlüsselwerte von Zuweisung2. Dann müssen wir die Find () -Methode verwenden, um das Element in der Karte zu erwerben. Wir verwenden die Funktion "begin () und end (), die dem Iterator zugeordnet ist. Dann konstruieren wir den Zeiger des ersten und zweiten Elements des Iterators und verwenden die Anweisung "Cout", um diese Werte zu drucken.

Jetzt wollen wir das Element mit dem Schlüsselwert 4 beseitigen. Auf diese Weise müssen wir die „n“ -Variable initialisieren. Der Datentyp dieser Variablen ist eine Ganzzahl. Dann werden wir die Funktion erase () verwenden. Diese Funktion enthält den Parameter des Wertes, den wir entfernt werden möchten. Die Anweisung "Cout" wird verwendet, um dieses Element zu löschen. Wieder haben wir die "für" -Schloop und den Zeiger des Iterators verwendet. Wir drucken die untere Grenze und die Obergrenze der Karte für die Zuweisung1 mit der Anweisung "Cout".

In der nächsten Zeile werden wir die Anweisung „Cout“ verwenden, um einen Zeiger zu erstellen, der auf den zweiten Wert der Zuweisung1 verweist1. Wir geben auch das Schlüsselwort "Endl" ein, um die nächste Zeile für die Codierung zu erhalten. Jetzt wird die Methode von Upper_Bound () von Zuweisung1 aufgerufen. Der Zeiger wird erstellt, um auf den zweiten Wert der Obergrenze der Zuordnung1 zu verweisen1.

Beispiel Nr. 2

In dieser Abbildung haben der Schlüsselwert und der mit dem Schlüssel verbundene Wert beide unterschiedliche Datentypen. Es ist nicht möglich, die Werte einzeln zu konfigurieren. Sie müssen paarweise zur Verfügung gestellt werden.

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

Karte Arbeitskräfte;
Arbeiter [221] = "Anikaa";
Arbeiter [320] = "Zeeshan";
Arbeiter [345] = "Daniyal";
Arbeiter [237] = "Dania";
Arbeiter [189] = "Azka";
Cout << "Workers[190]=" << Workers[237] << endl << endl;
Cout << "Size of the map: " << Workers.size() << endl;
Cout << endl << "The Original Order:" << endl;
für (Karte :: Iterator JJ = Arbeiter.Start(); JJ!= Arbeiter.Ende(); ++ JJ)

Cout << (*jj).first << ": " << (*jj).second << endl;

Cout << endl << "The Inverse Order:" << endl;
für (map :: Reverse_iterator jj = Arbeiter.rbegin (); JJ!= Arbeiter.zerreißen(); ++ JJ)

Cout << (*jj).first << ": " << (*jj).second << endl;

Zu Beginn des Programms werden wir vier wichtige Bibliotheken einbeziehen, darunter,, und . Immerhin wird der Standard -Namespace als STD verwendet. Wir konstruieren die Karte der Arbeiter. Wir werden zwei Datentypen als Argumente der Karte bereitstellen. Der Datentyp enthält Ganzzahl und Zeichenfolge. Jetzt werden wir den Arbeitern die IDs zuweisen. Wir verwenden das Array -Indexformat, um die Werte zuzuordnen. Die Anweisung „Cout“ wird verwendet, um den Namen des Arbeiters zu zeigen, dessen ID 190 ist.

Darüber hinaus haben wir die Anweisung "Cout" verwendet, um die Kartengröße anzuzeigen. Die Größe wird nach der Anweisung „Größe der Karte“ gedruckt. Als nächstes wird die Anweisung "Cout" verwendet, um die ursprüngliche Reihenfolge der IDs anzuzeigen. Innerhalb für Schleife verwenden wir den Befehl „Karte“. Wir initialisieren die Zeichenfolge und den Iterator. Dann starten wir die Karte der Arbeiter mit der Methode mit Beginn (). Um die Karte der Arbeiter zu beenden, haben wir die Funktion End () verwendet.

Im letzten Teil der „für“ Schleife haben wir den Wert des Iterators erhöht. Die Anweisung "Cout" wird verwendet, um die Elemente der Karte anzuzeigen. Dann werden wir erneut die Anweisung "Cout" verwenden, um die Zeile "Die inverse Reihenfolge" anzuzeigen. Wir werden die Methode begin () und end () verwenden, um die Elemente der Karte zu starten und zu beenden. Wir werden die Elemente iterieren, bis die Bedingung erfüllt ist. Am Ende wird die Anweisung „Cout“ verwendet, um die Elemente umgekehrt zu drucken.

Beispiel Nr. 3

Einige der Kartenfunktionen werden im folgenden Programm verwendet. Vor der Iterie für einen solchen Wert, der einem bestimmten Schlüssel entspricht, fügt es zunächst andere Elemente zur Karte hinzu.

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

Karte Std;
Std.einfügen (STD :: Paar(736, "Jamil");
Std.einfügen (STD :: Paar(233, "dua");
Std.einfügen (STD :: Paar(837, "Aima");
Std [348] = "Snbar";
STD [646] = "Tania";
Cout << "Map Size: " << Std.size() << endl << endl;
Cout << endl << "Real order of the values:" << endl;
für (map :: iterator iter = std.Start(); Iter!= Std.Ende(); ++ iter)

Cout << (*iter).first << ": " << (*iter).second << endl;

std :: map:: iterator it = std.Finden (348);
wenn es != Std.Ende())
std :: Cout < " << Std.find(348)->zweite << '\n';

Zunächst werden wir die Header -Dateien einbeziehen. Die Header -Datei befasst sich mit den Zeichenfolgen im Code. Die Header -Datei befasst sich mit den Eingangs- und Ausgabefunktionen. Die Header -Datei befasst sich mit der Karte. Und die letzte Header -Datei befasst sich mit den Nutzfunktionen. Beginnen wir die Codierung im Körper der Main () 0F -Funktion. Wir werden den Befehl "Karte" ausführen. Mit Hilfe von diesem initialisieren wir eine Karte durch die Schlüssel und ihre entsprechenden Werte. Der Datentyp der Schlüssel ist eine Ganzzahl, und der Datentyp ihrer Werte ist "String".

Jetzt werden wir die Markierungen und Namen der Schüler in der Karte mit Hilfe der Funktion Insert () einfügen. Wir verwenden diese Funktion, um die Daten der drei Schüler hinzuzufügen. Als nächstes werden wir das Array -Indexformat verwenden, um die Markierungen und Namen der Schüler einzufügen. Die Daten von zwei Schülern werden mit dem Array -Indexformat eingefügt.

Darüber hinaus werden wir die "Cout" -Methode anwenden. Die Anweisung "Cout" zeigt die Zeile „Kartegröße“ auf dem Bildschirm vor der Karte an. Innerhalb dieser „Cout“ -Anweisung werden wir die Methode Size () verwenden. Jetzt werden wir die Namen und die Nummern der Schüler im Originalformat zeigen. Die Anweisung „Cout“ wird verwendet, um den Text "Real Order der Werte" zu drucken,. Wir verwenden den Befehl „Endl“ auf beiden Seiten dieses Textes, um diesen Text in einer separaten Zeile zu drucken. Jetzt haben wir die "für" -Schloop verwendet. Wir werden auch die Funktion begin () verwenden, um den Vornamen und die Markierungen des Schülers auf einer Karte zu drucken.

In ähnlicher Weise wird die Methode End () verwendet, um den Nachnamen des Schülers auf einer Karte anzuzeigen. Die Anweisung „Cout“ zeigt diese ersten und letzten Werte. Am Ende des Programms werden wir eine andere Kartenfunktion verwenden, um () zu finden (). Wir möchten den Namen des Schülers entdecken, dessen Nummer 348 ist. Also nennen wir die Find () -Methode. Wir verwenden STD :: Map und Std :: Iterator. Dann haben wir den Zustand "If" verwendet. Wir wenden die Kartenfunktion End () an, um die Bedingung „If“ zu erfüllen. Um den Namen des Schülers zu drucken, dessen Markierungen 348 sind, werden wir die STD :: Cout -Methode anwenden. Wir erstellen auch den Zeiger, der auf den zweiten Wert der Karte verweist.

Abschluss

Wir haben in diesem Artikel eine C ++ - Karte und die Verwendung von Kartenfunktionen besprochen. Wir haben kurz demonstriert, Elemente hinzuzufügen und sie durch die Verwendung der Karte in verschiedenen Beispielen zu rufen. Karten sind die Komponente der Standard -Vorlagenbibliothek. Karten sind assoziative Behälter, die geordnete Schlüsselwertpaare enthalten. Fast jeder Schlüssel ist unterschiedlich und kann nur hinzugefügt oder vollständig entfernt werden. Schlüsselwerte können ihre zugehörigen Werte haben, die geändert werden. In einer Karte halten die definierten Werte die Daten zu dem Schlüssel, während die Schlüsselwerte normalerweise zum Anordnen und Identifizieren bestimmter Komponenten verwendet werden.