std::lista in C++ med exempel

Varför använda std::list?

Här är anledningarna till att använda std::List:

• Std::listan kan bättre jämföras med andra sekvensbehållare som array och vektor.
• De har bättre prestanda när det gäller att sätta in, flytta och utvinna element från vilken position som helst.
• Std::listan fungerar också bättre med algoritmer som utför sådana operationer intensivt.

Lista syntax

För att definiera std::listan måste vi importera header-fil. Här är syntaxen för std::list definition:

template < class Type, class Alloc =allocator<T> > class list;

Här är en beskrivning av ovanstående parametrar:

• T – Definierar typen av element som ingår. Du kan ersätta T med vilken datatyp som helst, även användardefinierade typer.
• Alloc – Definierar typen av allokeringsobjekt. Detta använder allocatorklassmallen som standard. Det är värdeberoende och använder en enkel minnesallokeringsmodell.

Exempel 1

#include <algorithm>
#include <iostream>
#include <list>
int main() {
	std::list<int> my_list = { 12, 5, 10, 9 };

	for (int x : my_list) {
		std::cout << x << '\n';
	}
}

Produktion:

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

Kodförklaring:

1. Inkludera algoritmhuvudfilen för att använda dess funktioner.
2. Inkludera iostream-huvudfilen för att använda dess funktioner.
3. Inkludera listhuvudfilen för att använda dess funktioner.
4. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
5. Skapa en lista med namnet my_list med en uppsättning av 4 heltal.
6. Använd en for-loop för att skapa en loopvariabel x. Denna variabel kommer att användas för att iterera över listelementen.
7. Skriv ut värdena för listan på konsolen.
8. Slutet av kroppen av för slinga.
9. Slutet på huvuddelen av funktionen main().

C++ Lista funktioner

Här är de vanliga std::listfunktionerna:

Funktion	BESKRIVNING
Föra in()	Denna funktion infogar ett nytt objekt före den position som iteratorn pekar på.
trycka tillbaka()	Denna funktion lägger till ett nytt objekt i slutet av listan.
push_front()	Den lägger till ett nytt objekt längst fram i listan.
pop_front()	Det tar bort listans första objekt.
storlek()	Denna funktion bestämmer antalet listelement.
främre()	För att avgöra listans första poster.
tillbaka()	För att avgöra listans sista post.
omvänd()	Det vänder på listobjekten.
sammanfoga()	Den slår samman två sorterade listor.

Konstruktörer

Här är listan över funktioner tillhandahålls av header fil:

• Standardkonstruktor std::list::list()- Den skapar en tom lista, det där, med noll element.
• Fill constructor std::list::list()- Den skapar en lista med n element och tilldelar ett värde på noll (0) till varje element.
• Range constructor std::list::list()- skapar en lista med många element i intervallet först till sist.
• Kopiera konstruktor std::list::list()- Den skapar en lista med en kopia av varje element som finns i den befintliga listan.
• Move constructor std::list::list()- skapar en lista med elementen i en annan lista med hjälp av flyttsemantik.
• Initializer list constructor std::list::list()-Den skapar en lista med elementen i en annan lista med hjälp av flyttsemantik.

Exempelvis 2

#include <iostream>
#include <list>
using namespace std;
int main(void) {
	list<int> l;
	list<int> l1 = { 10, 20, 30 };
	list<int> l2(l1.begin(), l1.end());
	list<int> l3(move(l1));  
	cout << "Size of list l: " << l.size() << endl;
	cout << "List l2 contents: " << endl;
	for (auto it = l2.begin(); it != l2.end(); ++it)
	      cout << *it << endl;
	cout << "List l3 contents: " << endl;
	for (auto it = l3.begin(); it != l3.end(); ++it)
		cout << *it << endl;
	return 0;
}

Produktion:

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

Kodförklaring:

1. Inkludera iostream-huvudfilen för att använda dess funktioner.
2. Inkludera listhuvudfilen för att använda dess funktioner.
3. Inkludera std-namnområdet i koden för att använda dess klasser utan att anropa det.
4. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
5. Skapa en tom lista med namnet l.
6. Skapa en lista med namnet l1 med en uppsättning av 3 heltal.
7. Skapa en lista som heter l2 med alla element i listan som heter l1, från början till slutet.
8. Skapa en lista med namnet l3 med hjälp av rörelsesemantik. Listan l3 kommer att ha samma innehåll som listan l2.
9. Skriv ut storleken på listan med namnet l på konsolen tillsammans med annan text.
10. Skriv ut lite text på konsolen.
11. Skapa en iterator som heter den och använd den för att iterera över elementen i listan som heter l2.
12. Skriv ut elementen i listan som heter l2 på konsolen.
13. Skriv ut lite text på konsolen.
14. Skapa en iterator som heter den och använd den för att iterera över elementen i listan som heter l3.
15. Skriv ut elementen i listan som heter l3 på konsolen.
16. Programmet måste returnera värde efter framgångsrikt slutförande.
17. Slutet på huvuddelen av funktionen main().

Behållaregenskaper

Här är listan över behållaregenskaper:

Fast egendom	BESKRIVNING
Sekvens	Sekvensbehållare ordnar sina element i en strikt linjär sekvens. Element nås genom deras position i sekvensen.
Dubbellänkad lista	Varje element har information om hur man lokaliserar föregående och nästa element. Detta tillåter konstant tid för insättning och radering.
Fördelarmedveten	Ett allokeringsobjekt används för att modifiera lagringsstorleken dynamiskt.

Infoga i en lista

Det finns olika funktioner som vi kan använda för att infoga värden i en lista. Låt oss demonstrera detta:

Exempelvis 3

#include <algorithm>
#include <iostream>
#include <list>
int main() {
	std::list<int> my_list = { 12, 5, 10, 9 };
	my_list.push_front(11);
	my_list.push_back(18);
	auto it = std::find(my_list.begin(), my_list.end(), 10);
	if (it != my_list.end()) {
		my_list.insert(it, 21);
	}
	for (int x : my_list) {
		std::cout << x << '\n';
	}
}

Produktion:

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

Kodförklaring:

1. Inkludera algoritmhuvudfilen för att använda dess funktioner.
2. Inkludera iostream-huvudfilen för att använda dess funktioner.
3. Inkludera listhuvudfilen för att använda dess funktioner.
4. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
5. Skapa en lista med namnet my_list med en uppsättning av 4 heltal.
6. Infoga elementet 11 längst fram i listan som heter my_list.
7. Infoga element 18 i slutet av listan som heter my_list.
8. Skapa en iterator och använd den för att hitta elementet 10 från listan my_list.
9. Använd en if-sats för att avgöra om elementet ovan hittades eller inte.
10. Sätt in element 21 före ovanstående element om det hittades.
11. Slutet på brödtexten i if-satsen.
12. Använd en for-loop för att skapa en loopvariabel x. Denna variabel kommer att användas för att iterera över listelementen.
13. Skriv ut värdena för listan på konsolen.
14. Änden av kroppen för en slinga.
15. Slutet på huvuddelen av funktionen main().

Ta bort från en lista

Det är möjligt att ta bort objekt från en lista. Erase()-funktionen låter dig ta bort ett objekt eller en rad objekt från en lista.

• För att radera ett enstaka objekt passerar du helt enkelt en heltalsposition. Objektet kommer att raderas.
• För att radera ett intervall passerar du start- och slutiteratorerna. Låt oss demonstrera detta.

Exempelvis 4

#include <algorithm>
#include <iostream>
#include <list>
using namespace std;
int main() {
	std::list<int> my_list = { 12, 5, 10, 9 };
	cout << "List elements before deletion: ";
	for (int x : my_list) {
		std::cout << x << '\n';
	}
	list<int>::iterator i = my_list.begin();
	my_list.erase(i);
	cout << "\nList elements after deletion: ";
	for (int x : my_list) {
		std::cout << x << '\n';
	}
	return 0;
}

Produktion:

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

Kodförklaring:

1. Inkludera algoritmhuvudfilen för att använda dess funktioner.
2. Inkludera iostream-huvudfilen för att använda dess funktioner.
3. Inkludera listhuvudfilen för att använda dess funktioner.
4. Inkludera std-namnutrymmet i vårt program för att använda dess klasser utan att anropa det.
5. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
6. Skapa en lista med namnet my_list med en uppsättning av 4 heltal.
7. Skriv ut lite text på konsolen.
8. Använd en for-loop för att skapa en loopvariabel x. Denna variabel kommer att användas för att iterera över listelementen.
9. Skriv ut värdena för listan på konsolen.
10. Slutet på kroppen av for-slingan.
11. Skapa en iterator i som pekar på det första elementet i listan.
12. Använd funktionen erase() som pekas av iteratorn i.
13. Skriv ut lite text på konsolen.
14. Använd en for-loop för att skapa en loopvariabel x. Denna variabel kommer att användas för att iterera över listelementen.
15. Skriv ut värdena för listan på konsolen. Detta kommer efter radering.
16. Slutet på kroppen av for-slingan.
17. Programmet måste returnera ett värde efter framgångsrikt slutförande.
18. Slutet på huvuddelen av funktionen main().

Sammanfattning

• std::listan är en lagringsbehållare.
• Det tillåter insättning och radering av objekt från var som helst vid konstant tid.
• Den är implementerad som en dubbellänk
• Std::listdata kan nås dubbelriktat och sekventiellt.
• std::list stöder inte snabb slumpmässig åtkomst. Den stöder dock sekventiell åtkomst från alla håll.
• Du kan sprida listelement av std::list i olika minnesbitar.
• Du kan krympa eller utöka std::list från båda ändarna efter behov under körning.
• För att infoga objekt i std::list använder vi funktionen insert().
• För att ta bort objekt från std::listan använder vi erase()-funktionen.