Bei Karte C++

Bei Karte C



Die C++ STL-Bibliothek stellt uns eine Map-Klasse zur Verfügung. Maps gelten als assoziative Container, die Objekte in einem Paar aus geordneten Schlüsselwerten und zugeordneten Werten enthalten. Es kann niemals zwei zugeordnete Werte mit demselben Schlüsselwert geben. Die Map-Klasse bietet viele Funktionen, aber hier werden wir die besprechen map.at() Funktion. Das dem Schlüsselwert zugeordnete Element wird als Parameter der Funktion übergeben, auf die mithilfe von verwiesen wird map.at() Funktion. Wenn wir versuchen, zu einem Element zu gelangen, das sich nicht innerhalb des Bereichs des Containers befindet, wird die map.at() -Funktion wertet den Bereich des Containers aus und löst eine Ausnahme aus.

Syntax der Funktion map.at()

Wir müssen der folgenden Syntax folgen, um die Funktion map.at() in C++ zu implementieren.







Kartenvariable.at ( Schlüssel / Wertepaar )



Wir haben das Kartenobjekt mit dem Namen „Map_variable“ mit der verwendet bei() Funktion. Es gibt das Element zurück, auf das direkt verwiesen wird und das auf den angegebenen Schlüsselwert zeigt. Die Datenschlüsselkarte hängt hauptsächlich von der Reichweite der Karte ab. Wenn dies nicht der Fall ist, besteht die Möglichkeit, dass zur Ausführungszeit eine Ausnahme oder ein Fehler zurückgegeben wird, der darauf hinweist, dass der Wert außerhalb des definierten Bereichs liegt. Jetzt werden wir diese Syntax in den C++-Codes verwenden, um zu zeigen, dass sie funktioniert.



Beispiel 1: Verwendung der Funktion map.at()

Das Programm wird implementiert, um die Funktion von map.at zu demonstrieren. Wir haben die verlinkt bei() Funktion mit der Karte() Funktion, die einige Eingabewerte übernimmt und ihre Funktionalität zeigt. Dazu haben wir den Kopfbereich des Programms gefüllt, indem wir das Kartenmodul mit einem anderen erforderlichen Modul für c++ importiert haben. Dann haben wir die angerufen hauptsächlich() Funktion für die Kartendeklaration aus der Kartenklasse. Das Objekt der Karte wird als „MyMap“ bezeichnet. Wir erstellen die Liste der Karten, indem wir den Kartenschlüssel und -wert angeben.





Danach haben wir die aufgerufen map.at() Funktion, die die angegebene Zeichenfolge auf eine Ganzzahl abbildet. Dann druckten wir die Ergebnisse aus der map.at() Funktion aus der for-Schleife. Die for-Schleife verwendet die Schlüsselwortreferenz „auto“. Das Schlüsselwort auto gibt an, dass der Initialisierer automatisch den Typ der Variablen von dem zu deklarierenden Typ entfernt. Die cout-Anweisung gibt die Paare in der Reihenfolge aus, die von der zurückgegeben wird map.at() Funktion.

#include

#include

#include


int Haupt ( )

std: :karte < std::string,int > MeineKarte = {

{ 'Apfel', 0 } ,

{ 'Trauben' , 0 } ,

{ 'Mangos' , 0 } }

MyMap.at ( 'Apfel' ) = 5 ;

MyMap.at ( 'Trauben' ) = 10 ;

MyMap.at ( 'Mangos' ) = 6 ;

zum ( Auto & m: Meine Karte ) {

std::cout << m.zuerst << ': ' << m.zweite << '\n' ; }

< stark > Rückkehr 0 ;

}



Jetzt haben wir die Ergebnisse des obigen Programms, das die implementiert map.at() Funktion. Alle angegebenen Ganzzahlen, die sich im Bereich befinden, werden für jede Zeichenfolge angezeigt.

Beispiel 2: Verwendung der Funktion map.at() für out_of_range Exception

Wir haben anhand eines Beispielprogramms die Verwendung von diskutiert map.at Funktion in C++. Jetzt haben wir eine weitere implementiert map.at im Programm. Aber dieses Mal gibt es den Wert zurück, der in der Map dargestellt wird, und auch die Ausnahme out_of_range, wenn der Schlüssel nicht angegeben ist. Da wir die nutzen müssen map.at Funktion, also haben wir das Kartenmodul in der Kopfzeile hinzugefügt. Dann haben wir die Hauptfunktion definiert, bei der „void“ als Parameter übergeben wird.

Innerhalb der Hauptfunktion haben wir den Listenkonstruktor initialisiert, indem wir das Kartenobjekt als „m1“ erstellt haben. Die Zuordnungsliste hat verschiedene Zeichenfolgen von Schlüsseln und die ganzzahligen Werte dagegen. Dann haben wir den Schlüssel „i“ gedruckt, indem wir ihn durch die geleitet haben map.at Funktion. Wir haben den Try-Catch-Block verwendet. Im Try-Block haben wir den Nicht-Existenz-Schlüssel in der präsentiert map.at Funktion. Da der Schlüssel außerhalb des Bereichs liegt, wird der try-Block den Fehler ausgeben.

#include

#include

mit Namensraum std;

int Haupt ( Leere ) {


Karte < Zeichen, int > m1 = {

{ 'ich' , 1 } ,

{ 'ich' , zwei } ,

{ 'n' , 3 } ,

{ 'in' , 4 } ,

{ 'x' , 5 } ,

} ;



cout << 'Zuordnungsschlüsselwert m1['i'] = ' << m1.at ( 'ich' ) << endl;



Versuchen {

m1.at ( 'Y' ) ;

} Fang ( const out_of_range & und ) {

zerr << 'Fehler bei' << e.was ( ) << endl;

}



Rückkehr 0 ;

}

Wir können anhand des Ausgabe-Screenshots visualisieren, dass die map.at() Die Funktion gibt nur die in der Karte vorhandenen Schlüssel zurück. Die Out-of-Range-Schlüssel geben den Fehler aus, da der Fehler angezeigt wird, wenn wir die Taste „y“ in übergeben haben map.at Funktion.

Beispiel 3: Verwendung der Funktion map.at() für den Zugriff auf Elemente

Auf ein Element kann mit dem angegebenen Ziffernelement aus der map.at-Funktion zugegriffen werden. Lassen Sie uns dieses Programm implementieren, um die obige Aussage zu erfüllen. Wir haben das Kartenmodul zuerst im Header-Bereich definiert, da es für den Zugriff auf die benötigt wird map.at Funktion. Dann haben wir die Hauptfunktion, bei der die Kartenklasse das Kartenobjekt als „Karte“ initialisiert. Mit diesem „Map“-Objekt haben wir die Schlüssel von Strings erzeugt und ihnen den Wert der Ziffer zugewiesen. Danach riefen wir die an map.at eine Funktion mit der cout-Anweisung und übergab die Taste „Example“ als Eingabe.

#include

#include

#include

mit Namensraum std;

int Haupt ( )

{

Karte < Zeichenkette, int > Karte;

Karte [ 'Mein' ] = 1 ;

Karte [ 'c++' ] = zwei ;

Karte [ 'Karte' ] = 3 ;

Karte [ 'Beispiel' ] = 4 ;

cout << Karte.at ( 'Beispiel' ) ;

Rückkehr 0 ;

}

Das digit-Element wird gegen den angegebenen Schlüssel in zurückgegeben map.at Funktion. Das Ergebnis ergibt den Wert „4“, da diese Ziffer dem Schlüsselelement „Beispiel“ einer Karte zugeordnet ist.

Beispiel 4: Verwenden der Funktion map.at() zum Modifizieren von Elementen

Betrachten wir eine einfache Instanz zum Ändern des Werts, der dem Schlüsselwert zugeordnet ist. Wir haben die Liste der Karte erstellt, indem wir die Kartenklasse aufgerufen und das Objekt „M1“ erstellt haben. Wir haben den Zeichenfolgenwert jedem Schlüssel der Karte zugewiesen. Dann müssen wir die verwenden map.at Funktion. In dem map.at -Funktion haben wir die angegebenen Schlüssel verwendet und diesen Schlüsseln die neuen Zeichenfolgenwerte zugewiesen. Jetzt werden diese Werte mit dem vorherigen geändert. Mit Hilfe der for-Schleife haben wir jedes Element aus der Karte iteriert und als Ausgabe angezeigt.

#include

#include

#include


mit Namensraum std;


int Haupt ( )

{

Karte < int, Zeichenkette > M1 = {

{ 10 , 'c++' } ,

{ zwanzig , 'Java' } ,

{ 30 , 'Python' } ,

{ 40 , 'scharf' } ,

{ fünfzig , 'OFFEN' } } ;




M1.at ( zwanzig ) = 'Tensorfluss' ;

M1.at ( 30 ) = 'Linux' ;

M1.at ( fünfzig ) = 'Skala' ;

cout << ' \n Elemente:' << endl;

zum ( Auto & X: M1 ) {

cout << x.zuerst << ': ' << x.Sekunde << '\n' ;

}


Rückkehr 0 ;

}

Beachten Sie, dass die als Ausgabe erhaltenen Werte die neu zugewiesenen Zeichenfolgenwerte in geändert haben map.at Funktion. Die aktualisierten Werte sind im folgenden Schnappschuss dargestellt.

Fazit

Der Artikel handelt von der Funktion map.at. Wir haben die Funktionalität der Funktion map.at() durch ihre Syntax bereitgestellt und das Beispiel ist mit einem C++-Compiler implementiert. Die Funktion map.at() ist sehr nützlich, da sie den Zugriff auf Elemente ermöglicht und eine eindeutige Ausnahme oder einen Fehler zurückgibt, der die Situation beschreibt, die beim Aufruf der Methode aufgetreten ist. Außerdem können wir dem Existenzschlüssel über die Funktion map.at neue Werte zuweisen.