std::list in C++ mit Beispiel

Was ist eine std::list?

In C++ bezieht sich std::list auf einen Speichercontainer. Mit std:list können Sie Elemente überall einfügen und entfernen. Die std::list ist als doppelt verkettete Liste implementiert. Auf Listendaten kann somit bidirektional und sequentiell zugegriffen werden.

Die Liste der Standardvorlagenbibliothek unterstützt keinen schnellen wahlfreien Zugriff, unterstützt aber den sequentiellen Zugriff aus allen Richtungen.

Sie können Listenelemente in verschiedenen Speicherblöcken verteilen. Die für den sequentiellen Zugriff auf Daten benötigten Informationen werden in einem Container gespeichert. Die std::list kann zur Laufzeit von beiden Enden nach Bedarf erweitert und verkleinert werden. Ein interner Zuordner erfüllt automatisch die Speicheranforderungen.

In diesem C++-Tutorial lernen Sie:

• Was ist eine std::list?
• Warum std::list verwenden?
• Listensyntax
• C++-Listenfunktionen
• Konstruktoren
• Containereigenschaften
• Einfügen in eine Liste
• Löschen aus einer Liste

Warum std::list verwenden?

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

• Die std::list schneidet im Vergleich zu anderen Sequenzcontainern wie Array und Vektor besser ab.
• Sie haben eine bessere Leistung beim Einfügen, Verschieben und Extrahieren von Elementen aus jeder Position.
• Die std::list funktioniert auch besser mit Algorithmen, die solche Operationen intensiv durchführen.

Listensyntax

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

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

Hier ist eine Beschreibung der obigen Parameter:

• T – Definiert den Typ des enthaltenen Elements.

  Sie können T durch jeden Datentyp ersetzen, sogar durch benutzerdefinierte Typen.

• Alloc – Definiert den Typ des Zuweisungsobjekts.

  Dies verwendet standardmäßig die allocator-Klassenvorlage. Es ist wertabhängig und verwendet ein einfaches Speicherzuweisungsmodell.

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

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die Algorithmus-Header-Datei ein, um ihre Funktionen zu verwenden.
2. Schließen Sie die iostream-Header-Datei ein, um ihre Funktionen zu nutzen.
3. Schließen Sie die Listen-Header-Datei ein, um ihre Funktionen zu nutzen.
4. Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine Liste namens my_list mit einem Satz von 4 Ganzzahlen.
6. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird verwendet, um über die Listenelemente zu iterieren.
7. Drucken Sie die Werte der Liste auf der Konsole aus.
8. Ende des Körpers der for-Schleife.
9. Ende des Hauptteils der Funktion main().

C++-Listenfunktionen

Hier sind die üblichen std::list-Funktionen:

Funktion Beschreibung insert () Diese Funktion fügt ein neues Element vor der Position ein, auf die der Iterator zeigt. push_back () Diese Funktion fügt ein neues Element am Ende der Liste hinzu first item.size()Diese Funktion bestimmt die Anzahl der Listenelemente.front()To bestimmt die ersten Elemente der Liste.back()To bestimmt das letzte Element der Liste.reverse()Kehrt die Listenelemente um.merge()Verbindet zwei sortierte Listen.

Konstruktoren

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

• 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 einen Wert von 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 bestehenden Liste enthalten ist.
• Move-Konstruktor std::list::list()- erstellt eine Liste mit den Elementen einer anderen Liste unter Verwendung der Move-Semantik.
• Initialisierer-Listenkonstruktor std::list::list() – Er erstellt eine Liste mit den Elementen einer anderen Liste unter Verwendung der Bewegungssemantik.

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

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die iostream-Header-Datei ein, um ihre Funktionen zu nutzen.
2. Schließen Sie die Listen-Header-Datei ein, um ihre Funktionen zu nutzen.
3. Schließen 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 innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine leere Liste namens l.
6. Erstellen Sie eine Liste namens l1 mit einem Satz von 3 ganzen Zahlen.
7. Erstelle eine Liste namens l2 mit allen Elementen in der Liste namens l1, vom Anfang bis zum Ende.
8. Erstellen Sie eine Liste mit dem Namen l3 mit Bewegungssemantik. Die Liste l3 hat denselben Inhalt wie die Liste l2.
9. Drucken Sie die Größe der Liste mit dem Namen l auf der Konsole zusammen mit anderem Text.
10. Text auf der Konsole ausgeben.
11. Erstellen Sie einen Iterator namens it und verwenden Sie ihn, um über die Elemente der Liste namens l2 zu iterieren.
12. Drucken Sie die Elemente der Liste mit dem Namen l2 auf der Konsole.
13. Drucken Sie etwas Text auf der Konsole.
14. Erstellen Sie einen Iterator namens it und verwenden Sie ihn, um über die Elemente der Liste namens l3 zu iterieren.
15. Drucken Sie die Elemente der Liste mit dem Namen l3 auf der Konsole.
16. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
17. Ende des Hauptteils der Funktion main().

Containereigenschaften

Hier ist die Liste der Containereigenschaften:

Eigentum Beschreibung SequenceSequence-Container ordnen ihre Elemente in einer streng linearen Reihenfolge. Auf Elemente wird über ihre Position in der Sequenz zugegriffen. Doppelt verknüpfte Liste Jedes Element enthält Informationen darüber, wie vorherige und nächste Elemente zu finden sind. Dies ermöglicht eine konstante Zeit für Einfüge- und Löschvorgänge.Allocator-awareEin Allocator-Objekt 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 dies 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';
	}
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die Algorithmus-Header-Datei ein, um ihre Funktionen zu verwenden.
2. Schließen Sie die iostream-Header-Datei ein, um ihre Funktionen zu nutzen.
3. Schließen Sie die Listen-Header-Datei ein, um ihre Funktionen zu nutzen.
4. Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine Liste namens my_list mit einem Satz von 4 Ganzzahlen.
6. Fügen Sie das Element 11 vor 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 it 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. Element 21 vor dem obigen Element einfügen, 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 verwendet, um über die Listenelemente zu iterieren.
13. Drucken Sie die Werte der Liste auf der Konsole aus.
14. Ende des Körpers der for-Schleife.
15. Ende des Hauptteils der Funktion main().

Löschen aus einer Liste

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 Ganzzahlposition. Das Element wird gelöscht.
• Um einen Bereich zu löschen, übergeben Sie den Start- und den End-Iterator. Lassen Sie uns dies 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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die Algorithmus-Header-Datei ein, um ihre Funktionen zu verwenden.
2. Schließen Sie die iostream-Header-Datei ein, um ihre Funktionen zu nutzen.
3. Schließen Sie die Listen-Header-Datei ein, um ihre Funktionen zu nutzen.
4. Fügen Sie den std-Namensraum in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
5. Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
6. Erstellen Sie eine Liste namens my_list mit einem Satz von 4 Ganzzahlen.
7. Drucken Sie etwas Text auf der Konsole.
8. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird verwendet, um über die Listenelemente zu iterieren.
9. Drucken Sie die Werte der Liste auf der Konsole aus.
10. Ende des Körpers der for-Schleife.
11. Erzeuge 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 etwas Text auf der Konsole.
14. Verwenden Sie eine for-Schleife, um eine Schleifenvariable x zu erstellen. Diese Variable wird verwendet, um über die Listenelemente zu iterieren.
15. Drucken Sie die Werte der Liste auf der Konsole aus. Dies kommt nach dem Löschen.
16. Ende des Körpers der for-Schleife.
17. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
18. Ende des Hauptteils der Funktion main().

Zusammenfassung:

• Die std::list ist ein Speichercontainer.
• Es ermöglicht das Einfügen und Löschen von Elementen von überall zur konstanten 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().