Karta in C++ Standard Template Library (STL)

Vad är Map in C++?

In C++, en MAP är en associativ behållare som lagrar objekt i mappad form. Varje objekt i kartan består av ett nyckelvärde och ett mappat värde. Två mappade värden kan inte dela samma nyckelvärden.

Nyckelvärdena är användbara för att sortera och identifiera element unikt, medan de mappade värdena lagrar innehållet som är associerat med varje nyckel. De två kan skilja sig åt i typ, men medlemstypen kombinerar dem till ett par som innehåller båda.

Innan du skriver någon kod är det bra att veta varför en karta ofta är rätt behållare att sträcka sig efter.

Varför använda std::map?

Här är anledningar till att använda en karta:

• std::map lagrar endast unika nycklar, i sorterad ordning baserat på de valda sorteringskriterierna.
• Det är enkelt och snabbt att söka efter element med hjälp av tangenten.
• Endast ett element är fäst vid varje nyckel.
• std::map kan användas som en associativ array.
• std::map kan implementeras med hjälp av balanserade binära träd.

För att utnyttja dessa fördelar, börja med deklarationssyntaxen.

syntax

För att deklarera std::map, använd denna syntax:

std::map<key_datatype, value_datatype>map_name; 

• Ocuco-landskapet nyckeldatatyp anger kartnycklarnas datatyp.
• Ocuco-landskapet värdedatatyp anger datatypen för de värden som motsvarar kartnycklarna.
• Ocuco-landskapet kartnamn är namnet på kartan.

Till exempel:

map<string, int> my_map; 

Vi deklarerade en karta med namnet my_map. Kartan kommer att ha en sträng som nyckeldatatyp och ett heltal som värdedatatyp.

Medlemstyper

Medlemsfunktionerna kan använda följande medlemstyper antingen som parametrar eller returtyp:

• Nyckeltyp: Nyckel (den första parametern i mallen)
• mappad_type: T (den andra parametern i mallen)
• key_compare: Jämför (den tredje parametern i mallen)
• allocator_type: Alloc (den fjärde parametern i mallen)
• värde typ: par
• värde_jämför: Kapslad funktionsklass för att jämföra element
• referens: allocator_type::referens
• const_reference: allocator_type::const_reference
• pekare: allocator_type::pointer
• const_pointer: allocator_type::const_pointer
• iterator: en dubbelriktad iterator till value_type
• konst_iterator: en dubbelriktad iterator till const value_type
• reverse_iterator: en omvänd iterator
• const_reverse_iterator: en konstant omvänd iterator
• skillnadstyp: ptrdiff_t
• Storleks typ: storlek_t

Inbyggda funktioner för std::map

std::map kommer med inbyggda funktioner. Några av dessa inkluderar:

• Börja () – Den här funktionen returnerar iteratorn till det första elementet på kartan.
• storlek() – Den här funktionen returnerar antalet objekt i en karta.
• tömma() – Den här funktionen returnerar ett booleskt värde som anger om en karta är tom.
• insert(pair(nyckel, värde)) – Den här funktionen infogar ett nytt nyckel-värde-par i en karta.
• hitta(värde) – Denna funktion ger iteratorn till val-elementet om det hittas. Annars returnerar den m.end().
• radera (iteratorposition) – Den här funktionen tar bort objektet vid den position som iteratorn pekar på.
• radera(konst g) – Den här funktionen tar bort nyckel-värdet g från en karta.
• klar() – Den här funktionen tar bort alla objekt från en karta.

Med funktionerna definierade omsätter följande exempel dem i praktiken, med början med iteration.

Itererar över kartelement

Du kan iterera över kartelementen. Vi behöver bara skapa en iterator och använda den för detta. Till exempel:

Exempelvis 1

#include <iostream>
#include <string>
#include <map> 

using namespace std;
int main() {

	map<int, string> Students;

	Students.insert(std::pair<int, string>(200, "Alice"));

	Students.insert(std::pair<int, string>(201, "John"));

	cout << "Map size is: " << Students.size() << endl;

	cout << endl << "Default map Order is: " << endl;

	for (map<int, string>::iterator it = Students.begin(); it != Students.end(); ++it) {

		cout << (*it).first << ": " << (*it).second << endl;
	}
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera stränghuvudfilen i vår kod för att använda dess funktioner.
3. Inkludera karthuvudfilen i vår kod för att använda dess funktioner.
4. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
5. Anropa main()-funktionen. { markerar början av funktionens brödtext.
6. Skapa en karta med namnet Studenter där nycklarna kommer att vara heltal och värdena kommer att vara strängar.
7. Infoga värden i kartan Studenter. En nyckel på 200 och ett värde på Alice kommer att infogas i kartan.
8. Infoga värden i kartan Studenter. En nyckel på 201 och ett värde på John kommer att infogas i kartan.
9. Använd funktionen size() för att hämta storleken på kartan med namnet Studenter. Detta ska returnera 2.
10. Skriv ut lite text på konsolen.
11. Använd en for-loop för att skapa en iterator som heter den för att iterera över elementen på kartan som heter Studenter.
12. Skriv ut värdena på kartan Studenter på konsolen.
13. Slutet på kroppen av for-slingan.
14. Slutet på huvuddelen av funktionen main().

Infogar data i std::map

Du kan mata in objekt i std::map med hjälp av funktionen insert(). Kom ihåg att std::map-nycklarna måste vara unika.

Så den kontrollerar först om varje nyckel finns i mappningen. Om den finns kommer posten inte att infogas, men den returnerar iteratorn för den befintliga posten. Om den inte finns infogas posten.

Funktionen har följande varianter:

• infoga (par) – med denna variant infogas ett nyckel-värde-par i kartan.
• infoga(start_itr, slut_itr) – med denna variant kommer posterna att infogas inom det intervall som definieras av start_itr och end_itr från en annan karta.

Funktionen insert_or_assign() fungerar på samma sätt som funktionen insert(), men om den givna nyckeln redan finns i mappningen kommer dess värde att ändras.

Exempelvis 2

#include <map>
#include <iostream>

using namespace std;

int main() {

	map<int, int> m{ {1,3} , {2,4} , {3,5} };

	m.insert({ 5, 6 });
	m.insert({ 1, 8 });

	m.insert_or_assign(1, 6);  
	
	cout << "Key\tElement\n";
	for (auto itr = m.begin(); itr != m.end(); ++itr) {
		cout << itr->first << '\t' << itr->second << '\n';
	}
	return 0;
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera karthuvudfilen i vår kod för att använda dess funktioner.
2. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
3. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
4. Anropa main()-funktionen. { markerar början av funktionens brödtext.
5. Skapa en karta som heter m där nycklarna kommer att vara heltal och värdena kommer att vara heltal. Tre poster har gjorts i kartan.
6. Infoga en ny post i kartan m. En nyckel på 5 och ett värde på 6 kommer att infogas i kartan.
7. Försöker skriva in en redan befintlig nyckel. Eftersom nyckeln 1 redan finns i kartan kommer inmatningen inte att göras.
8. Använder funktionen insert_or_assign() för att infoga eller ändra en befintlig post. Eftersom nyckel 1 redan finns kommer dess värde att ändras till 6.
9. Skriv ut lite text på konsolen. Tecknet "\t" skapar ett horisontellt mellanslag medan tecknet "\n" flyttar muspekaren till nästa rad.
10. Använd för slinga för att skapa en iterator som heter itr för att iterera över elementen på kartan som heter m.
11. Skriv ut värdena för kartan m på konsolen. Tecknet "\t" skapar ett horisontellt mellanslag mellan varje tangent och dess motsvarande värde. Däremot flyttar tecknet "\n" muspekaren till nästa rad efter varje iteration.
12. Slutet på kroppen av for-slingan.
13. Programmet måste returnera ett värde efter framgångsrikt slutförande.
14. Slutet på huvuddelen av funktionen main().

Söker i en karta

Vi kan använda funktionen find() för att söka efter element i en karta med hjälp av deras nycklar. Om nyckeln inte hittas returnerar funktionen std::map::end. Annars returneras en iterator för det sökta elementet.

Exempelvis 3

#include <iostream>
#include <string>
#include <map> 
using namespace std;
int main() {
	map<int, string> Students;
	Students.insert(std::pair<int, string>(200, "Alice"));
	Students.insert(std::pair<int, string>(201, "John"));
	std::map<int, string>::iterator it = Students.find(201);
	if (it != Students.end()) {
		std::cout << endl << "Key 201 has the value: => "<< Students.find(201)->second << '\n';
	}
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner utan att få fel.
2. Inkludera stränghuvudfilen i vår kod för att använda dess funktioner utan att få fel.
3. Inkludera karthuvudfilen i vår kod för att använda dess funktioner utan att få fel.
4. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
5. Anropa main()-funktionen. { markerar början på main()-funktionens brödtext.
6. Skapa en karta med namnet Studenter vars nycklar kommer att vara heltal och värdesträngar.
7. Infoga värden i kartan Studenter. En nyckel på 200 och ett värde på Alice kommer att infogas i kartan.
8. Infoga värden i kartan Studenter. En nyckel på 201 och ett värde på John kommer att infogas i kartan.
9. Leta efter värdet som är kopplat till en nyckel på 201.
10. Använd en if-sats för att kontrollera om värdet för nyckeln hittas.
11. Skriv ut värdet på nyckeln bredvid lite text på konsolen.
12. Slutet på brödtexten i if-satsen.
13. Slutet på huvuddelen av funktionen main().

Ta bort data från en karta

Vi kan använda funktionen erase() för att ta bort ett värde från en karta. Vi skapar helt enkelt en iterator som pekar på det element som ska tas bort. Iteratorn skickas sedan till funktionen erase().

Exempelvis 4

#include <iostream>
#include <string>
#include <map>

using namespace std;
int main() {

	map<std::string, int> my_map;

	my_map.insert(std::make_pair("cow", 1));

	my_map.insert(std::make_pair("cat", 2));

	my_map["lion"] = 3;

	map<std::string, int>::iterator it = my_map.find("cat");

	my_map.erase(it);

	for (map<string, int>::iterator it = my_map.begin(); it != my_map.end(); ++it)

		cout << (*it).first << ": " << (*it).second << endl;

  return 0;
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera stränghuvudfilen i vår kod för att använda dess funktioner.
3. Inkludera karthuvudfilen i vår kod för att använda dess funktioner.
4. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
5. Anropa main()-funktionen. { markerar början på main()-funktionens brödtext.
6. Skapa en karta som heter my_map vars nycklar kommer att vara strängar och värden heltal.
7. Infoga värden i kartan my_map. En nyckel av ko och ett värde på 1 kommer att infogas i kartan.
8. Infoga värden i kartan my_map. En nyckel av Cat och ett värde på 2 kommer att infogas i kartan.
9. Lägg till ett värde 3 i kartan my_map med en nyckel från ett lejon.
10. Skapa en iterator för att iterera över kartan my_map och leta efter nyckelkatten.
11. Ta bort elementet som iteratorn pekar på.
12. Använd en iterator för att iterera över elementen i kartan my_map från början till slut.
13. Skriv ut innehållet på kartan my_map på konsolen.
14. Programmet måste returnera utdata efter framgångsrikt slutförande.
15. Slutet på huvuddelen av funktionen main().

Vanliga frågor