std::list în C++ cu Exemplu

De ce să folosiți std::list?

Iată motivele utilizării std::List:

• Std::list se compară mai bine cu alte containere de secvențe, cum ar fi matrice și vector.
• Au o performanță mai bună în introducerea, mutarea și extragerea elementelor din orice poziție.
• De asemenea, std::list se descurcă mai bine cu algoritmii care efectuează astfel de operațiuni intens.

Sintaxa listei

Pentru a defini lista std::, trebuie să importam fișier antet. Iată sintaxa definiției std::list:

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

Iată o descriere a parametrilor de mai sus:

• T – Definește tipul de element conținut. Puteți înlocui T cu orice tip de date, chiar și cu tipuri definite de utilizator.
• Alloc – Definește tipul obiectului alocător. Acesta utilizează în mod implicit șablonul de clasă alocător. Este dependent de valoare și folosește un model simplu de alocare a memoriei.

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

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet al algoritmului pentru a-i folosi funcțiile.
2. Includeți fișierul antet iostream pentru a-i folosi funcțiile.
3. Includeți fișierul antet listei pentru a utiliza funcțiile acestuia.
4. Apelați funcția main(). Logica programului ar trebui adăugată în corpul acestei funcții.
5. Creați o listă numită my_list cu un set de 4 numere întregi.
6. Utilizați o buclă for pentru a crea o variabilă de buclă x. Această variabilă va fi folosită pentru a itera elementele listei.
7. Tipăriți valorile listei pe consolă.
8. Capătul corpului pentru bucla.
9. Sfârșitul corpului funcției main().

C++ Lista de funcții

Iată funcțiile comune std::list:

Funcţie	Descriere
introduce()	Această funcție inserează un nou element înainte de poziția indicată de iterator.
împinge înapoi()	Această funcție adaugă un articol nou la sfârșitul listei.
push_front()	Se adaugă un element nou în partea de față a listei.
pop_front()	Acesta șterge primul element al listei.
mărimea()	Această funcție determină numărul de elemente din listă.
față()	Pentru a determina primele elemente ale listei.
înapoi()	Pentru a determina ultimul element al listei.
verso()	Acesta inversează elementele din listă.
combina()	Îmbină două liste sortate.

Constructorii

Iată lista cu funcții furnizate de fișier antet:

• Constructor implicit std::list::list()- creează o listă goală, care, cu zero elemente.
• Constructor de umplere std::list::list() - Creează o listă cu n elemente și atribuie o valoare de zero (0) fiecărui element.
• Constructorul de interval std::list::list()- creează o listă cu multe elemente în intervalul de la primul până la ultimul.
• Copy constructor std::list::list()- Creează o listă cu o copie a fiecărui element conținut în lista existentă.
• Move constructor std::list::list()- creează o listă cu elementele unei alte liste folosind semantica mutarii.
• Constructorul listei de inițializare std::list::list()-Creează o listă cu elementele unei alte liste folosind semantica de mutare.

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

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet iostream pentru a-i folosi funcțiile.
2. Includeți fișierul antet listei pentru a utiliza funcțiile acestuia.
3. Includeți spațiul de nume std în cod pentru a-și folosi clasele fără a-l apela.
4. Apelați funcția main(). Logica programului ar trebui adăugată în corpul acestei funcții.
5. Creați o listă goală numită l.
6. Creați o listă numită l1 cu un set de 3 numere întregi.
7. Creați o listă numită l2 cu toate elementele din lista numită l1, de la început până la sfârșit.
8. Creați o listă numită l3 folosind semantica de mutare. Lista l3 va avea același conținut ca și lista l2.
9. Tipăriți dimensiunea listei numite l pe consolă alături de alt text.
10. Tipăriți ceva text pe consolă.
11. Creați un iterator numit și utilizați-l pentru a itera elementele listei numite l2.
12. Tipăriți elementele listei numite l2 pe consolă.
13. Tipăriți ceva text pe consolă.
14. Creați un iterator numit și utilizați-l pentru a itera elementele listei numite l3.
15. Tipăriți elementele listei numite l3 pe consolă.
16. Programul trebuie să returneze valoare după finalizarea cu succes.
17. Sfârșitul corpului funcției main().

Proprietățile containerului

Iată lista proprietăților containerului:

Proprietatea	Descriere
Secvenţă	Containerele de secvențe își ordonează elementele într-o secvență liniară strictă. Elementele sunt accesate prin poziția lor în secvență.
Listă dublu legată	Fiecare element are informații despre cum să localizați elementele anterioare și următoare. Acest lucru permite un timp constant pentru operațiunile de inserare și ștergere.
Conștient de alocător	Un obiect alocător este utilizat pentru modificarea dinamică a dimensiunii stocării.

Inserarea într-o listă

Există diferite funcții pe care le putem folosi pentru a insera valori într-o listă. Să demonstrăm asta:

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

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet al algoritmului pentru a-i folosi funcțiile.
2. Includeți fișierul antet iostream pentru a-i folosi funcțiile.
3. Includeți fișierul antet listei pentru a utiliza funcțiile acestuia.
4. Apelați funcția main(). Logica programului ar trebui adăugată în corpul acestei funcții.
5. Creați o listă numită my_list cu un set de 4 numere întregi.
6. Introduceți elementul 11 ​​în partea din față a listei numită my_list.
7. Introduceți elementul 18 la sfârșitul listei numită my_list.
8. Creați un iterator și folosiți-l pentru a găsi elementul 10 din lista my_list.
9. Utilizați o declarație if pentru a determina dacă elementul de mai sus a fost găsit sau nu.
10. Introduceți elementul 21 înaintea elementului de mai sus dacă a fost găsit.
11. Sfârșitul corpului declarației if.
12. Utilizați o buclă for pentru a crea o variabilă de buclă x. Această variabilă va fi folosită pentru a itera elementele listei.
13. Tipăriți valorile listei pe consolă.
14. Sfârșitul corpului buclei for.
15. Sfârșitul corpului funcției main().

Ștergerea dintr-o listă

Este posibil să ștergeți elemente dintr-o listă. Funcția erase() vă permite să ștergeți un articol sau o serie de articole dintr-o listă.

• Pentru a șterge un singur element, treceți pur și simplu cu o poziție întreagă. Elementul va fi șters.
• Pentru a șterge un interval, treceți iteratorii de început și de sfârșit. Să demonstrăm asta.

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

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet al algoritmului pentru a-i folosi funcțiile.
2. Includeți fișierul antet iostream pentru a-i folosi funcțiile.
3. Includeți fișierul antet listei pentru a utiliza funcțiile acestuia.
4. Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele fără a-l apela.
5. Apelați funcția main(). Logica programului ar trebui adăugată în corpul acestei funcții.
6. Creați o listă numită my_list cu un set de 4 numere întregi.
7. Tipăriți ceva text pe consolă.
8. Utilizați o buclă for pentru a crea o variabilă de buclă x. Această variabilă va fi folosită pentru a itera elementele listei.
9. Tipăriți valorile listei pe consolă.
10. Capătul corpului buclei for.
11. Creați un iterator i care indică primul element al listei.
12. Utilizați funcția erase() indicată de iteratorul i.
13. Tipăriți ceva text pe consolă.
14. Utilizați o buclă for pentru a crea o variabilă de buclă x. Această variabilă va fi folosită pentru a itera elementele listei.
15. Tipăriți valorile listei pe consolă. Aceasta vine după ștergere.
16. Capătul corpului buclei for.
17. Programul trebuie să returneze o valoare la finalizarea cu succes.
18. Sfârșitul corpului funcției main().

Rezumat

• Std::list este un container de stocare.
• Permite inserarea și ștergerea articolelor de oriunde în timp constant.
• Este implementat ca o legătură dublă
• Datele std::list pot fi accesate bi-direcțional și secvenţial.
• std::list nu acceptă acces rapid aleator. Cu toate acestea, acceptă accesul secvenţial din toate direcţiile.
• Puteți împrăștia elemente de listă ale std::list în diferite bucăți de memorie.
• Puteți micșora sau extinde std::list de la ambele capete după cum este necesar în timpul rulării.
• Pentru a insera elemente în std::list, folosim funcția insert().
• Pentru a șterge elemente din lista std::, folosim funcția erase().