std::list in C++ mit Beispiel

Warum std::list verwenden?

Hier sind die Gründe für die Verwendung von std::List:

• Die std::list ist im Vergleich zu anderen Sequenzcontainern wie Array und Vektor besser.
• Sie bieten eine bessere Leistung beim Einfügen, Verschieben und Extrahieren von Elementen aus jeder Position.
• Auch bei Algorithmen, die solche Operationen intensiv ausführen, kommt std::list besser zurecht.

Listensyntax

Um die std::list zu definieren, müssen wir die importieren Header-Datei. Hier ist die std::list-Definitionssyntax:

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

Hier ist eine Beschreibung der oben genannten Parameter:

• T – Definiert den Typ des enthaltenen Elements. Sie können T durch jeden Datentyp ersetzen, auch durch benutzerdefinierte Typen.
• Alloc – Definiert den Typ des Allocator-Objekts. Hierbei wird standardmäßig die Allocator-Klassenvorlage verwendet. Es ist wertabhängig und verwendet ein einfaches Speicherzuweisungsmodell.

Beispiele 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';
	}
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die Algorithmus-Header-Datei ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die iostream-Headerdatei ein, um ihre Funktionen zu nutzen.
3. Fügen Sie die Listenheaderdatei ein, um ihre Funktionen zu nutzen.
4. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine Liste mit dem Namen my_list mit einem Satz von 4 Ganzzahlen.
6. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird zum Durchlaufen der Listenelemente verwendet.
7. Drucken Sie die Werte der Liste auf der Konsole aus.
8. Ende des Körpers des for-Schleife.
9. Ende des Hauptteils der main()-Funktion.

C++ Listenfunktionen

Hier sind die allgemeinen std::list-Funktionen:

Funktion	Beschreibung
einfügen()	Diese Funktion fügt ein neues Element vor der Position ein, auf die der Iterator zeigt.
push_back()	Diese Funktion fügt am Ende der Liste ein neues Element hinzu.
push_front()	Es fügt ein neues Element am Anfang der Liste hinzu.
pop_front()	Es löscht das erste Element der Liste.
Größe()	Diese Funktion ermittelt die Anzahl der Listenelemente.
Vorderseite()	Bestimmt die ersten Elemente der Liste.
zurück()	Bestimmt das letzte Element der Liste.
umkehren()	Es kehrt die Listenelemente um.
verschmelzen()	Es führt zwei sortierte Listen zusammen.

Konstrukteure

Hier ist die Liste von Funktionen bereitgestellt von der Header-Datei:

• Standardkonstruktor std::list::list() – Er erstellt eine leere Liste mit null Elementen.
• Füllkonstruktor std::list::list() – Er erstellt eine Liste mit n Elementen und weist jedem Element den Wert Null (0) zu.
• Bereichskonstruktor std::list::list() – erstellt eine Liste mit vielen Elementen im Bereich vom ersten bis zum letzten.
• Kopierkonstruktor std::list::list() – Er erstellt eine Liste mit einer Kopie jedes Elements, das in der vorhandenen Liste enthalten ist.
• Move-Konstruktor std::list::list() – erstellt eine Liste mit den Elementen einer anderen Liste mithilfe der Move-Semantik.
• Initialisierungslistenkonstruktor std::list::list() – Er erstellt eine Liste mit den Elementen einer anderen Liste mithilfe der Verschiebungssemantik.

Beispiel 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Headerdatei ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die Listenheaderdatei ein, um ihre Funktionen zu nutzen.
3. Fügen Sie den std-Namespace in den Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
4. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine leere Liste mit dem Namen l.
6. Erstellen Sie eine Liste mit dem Namen l1 mit einer Menge von 3 Ganzzahlen.
7. Erstellen Sie eine Liste mit dem Namen l2 mit allen Elementen in der Liste mit dem Namen l1, vom Anfang bis zum Ende.
8. Erstellen Sie mithilfe der Verschiebungssemantik eine Liste mit dem Namen l3. Die Liste l3 hat denselben Inhalt wie die Liste l2.
9. Geben Sie die Größe der Liste mit dem Namen l zusammen mit anderem Text auf der Konsole aus.
10. Drucken Sie einen Text auf der Konsole.
11. Erstellen Sie einen Iterator mit dem Namen it und verwenden Sie ihn, um die Elemente der Liste mit dem Namen l2 zu durchlaufen.
12. Drucken Sie die Elemente der Liste mit dem Namen l2 auf der Konsole aus.
13. Drucken Sie einen Text auf der Konsole.
14. Erstellen Sie einen Iterator mit dem Namen it und verwenden Sie ihn, um die Elemente der Liste mit dem Namen l3 zu durchlaufen.
15. Drucken Sie die Elemente der Liste mit dem Namen l3 auf der Konsole aus.
16. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
17. Ende des Hauptteils der main()-Funktion.

Containereigenschaften

Hier ist die Liste der Containereigenschaften:

Immobilien	Beschreibung
Reihenfolge	Sequenzcontainer ordnen ihre Elemente in einer streng linearen Reihenfolge. Der Zugriff auf Elemente erfolgt über ihre Position in der Sequenz.
Doppelt verlinkte Liste	Jedes Element verfügt über Informationen zum Auffinden vorheriger und nächster Elemente. Dadurch bleibt die Zeit für Einfüge- und Löschvorgänge konstant.
Allokatorbewusst	Ein Allokatorobjekt wird zum dynamischen Ändern der Speichergröße verwendet.

Einfügen in eine Liste

Es gibt verschiedene Funktionen, mit denen wir Werte in eine Liste einfügen können. Lassen Sie uns das demonstrieren:

Beispiel 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';
	}
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die Algorithmus-Header-Datei ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die iostream-Headerdatei ein, um ihre Funktionen zu nutzen.
3. Fügen Sie die Listenheaderdatei ein, um ihre Funktionen zu nutzen.
4. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine Liste mit dem Namen my_list mit einem Satz von 4 Ganzzahlen.
6. Fügen Sie das Element 11 am Anfang der Liste mit dem Namen my_list ein.
7. Fügen Sie Element 18 am Ende der Liste mit dem Namen my_list ein.
8. Erstellen Sie einen Iterator und verwenden Sie ihn, um das Element 10 aus der Liste my_list zu finden.
9. Verwenden Sie eine if-Anweisung, um festzustellen, ob das obige Element gefunden wurde oder nicht.
10. Fügen Sie Element 21 vor dem obigen Element ein, falls es gefunden wurde.
11. Ende des Hauptteils der if-Anweisung.
12. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird zum Durchlaufen der Listenelemente verwendet.
13. Drucken Sie die Werte der Liste auf der Konsole aus.
14. Ende des Körpers der for-Schleife.
15. Ende des Hauptteils der main()-Funktion.

Aus einer Liste löschen

Es ist möglich, Elemente aus einer Liste zu löschen. Mit der Funktion erase() können Sie ein Element oder eine Reihe von Elementen aus einer Liste löschen.

• Um ein einzelnes Element zu löschen, übergeben Sie einfach eine ganzzahlige Position. Der Artikel wird gelöscht.
• Um einen Bereich zu löschen, übergeben Sie den Start- und den End-Iterator. Lassen Sie uns das demonstrieren.

Beispiel 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die Algorithmus-Header-Datei ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die iostream-Headerdatei ein, um ihre Funktionen zu nutzen.
3. Fügen Sie die Listenheaderdatei ein, um ihre Funktionen zu nutzen.
4. Fügen Sie den std-Namespace in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
5. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
6. Erstellen Sie eine Liste mit dem Namen my_list mit einem Satz von 4 Ganzzahlen.
7. Drucken Sie einen Text auf der Konsole.
8. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird zum Durchlaufen der Listenelemente verwendet.
9. Drucken Sie die Werte der Liste auf der Konsole aus.
10. Ende des Körpers der for-Schleife.
11. Erstellen Sie einen Iterator i, der auf das erste Element der Liste zeigt.
12. Verwenden Sie die Funktion erase(), auf die der Iterator i zeigt.
13. Drucken Sie einen Text auf der Konsole.
14. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird zum Durchlaufen der Listenelemente verwendet.
15. Drucken Sie die Werte der Liste auf der Konsole aus. Dies geschieht nach dem Löschen.
16. Ende des Körpers der for-Schleife.
17. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
18. Ende des Hauptteils der main()-Funktion.

Zusammenfassung

• Die std::list ist ein Speichercontainer.
• Es ermöglicht das Einfügen und Löschen von Elementen von überall und zu konstanter Zeit.
• Es ist als Double-Link implementiert
• Auf die std::list-Daten kann bidirektional und sequentiell zugegriffen werden.
• std::list unterstützt keinen schnellen Direktzugriff. Es unterstützt jedoch den sequentiellen Zugriff aus allen Richtungen.
• Sie können Listenelemente von std::list in verschiedenen Speicherblöcken verteilen.
• Sie können std::list von beiden Enden nach Bedarf während der Laufzeit verkleinern oder erweitern.
• Um Elemente in std::list einzufügen, verwenden wir die Funktion insert().
• Um Elemente aus der std::list zu löschen, verwenden wir die Funktion erase().