std :: liste dans C++ avec exemple

Qu'est-ce qu'une liste std :: ?

In C++`std::list` désigne un conteneur de stockage. `std::list` permet d'insérer et de supprimer des éléments à partir de n'importe quel emplacement. `std::list` est implémentée comme une liste doublement chaînée, ce qui signifie que les données de la liste sont accessibles de manière bidirectionnelle et séquentielle.

La liste de la bibliothèque de modèles standard ne prend pas en charge l'accès aléatoire rapide, mais elle prend en charge l'accès séquentiel dans toutes les directions.

Vous pouvez disperser les éléments de la liste dans différents blocs de mémoire. Les informations nécessaires à l'accès séquentiel aux données sont stockées dans un conteneur. La std::list peut s'étendre et se réduire des deux côtés selon les besoins pendant l'exécution. Un allocateur interne répond automatiquement aux exigences de stockage.

Ces caractéristiques soulèvent une question pratique : quand faut-il réellement recourir à une liste ?

Pourquoi utiliser std :: list ?

Voici les raisons d'utiliser std::list :

• La classe std::list est plus performante que d'autres conteneurs de séquences comme les tableaux et les vecteurs.
• Ils offrent de meilleures performances en matière d'insertion, de déplacement et d'extraction.tracéléments de ting depuis n'importe quelle position.
• Le std::list fait également mieux avec les algorithmes qui effectuent de telles opérations de manière intensive.

Les raisons étant claires, l'étape suivante consiste à définir la syntaxe qui en déclare une.

Syntaxe de liste

Pour définir la std::list, nous devons importer le En tête de fichier. Voici la syntaxe de définition std::list :

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

Voici une description des paramètres ci-dessus :

• T – Définit le type de l'élément contenu. Vous pouvez remplacer T par n'importe quel type de données, même des types définis par l'utilisateur.
• Alloc – Définit le type de l'objet allocateur. Par défaut, il utilise le modèle de classe allocateur. Il dépend de la valeur et utilise un modèle d'allocation mémoire simple.

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

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête de l'algorithme pour utiliser ses fonctions.
2. Incluez le fichier d'en-tête iostream pour utiliser ses fonctions.
3. Incluez le fichier d'en-tête de liste pour utiliser ses fonctions.
4. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
5. Créez une liste nommée my_list avec un ensemble de 4 entiers.
6. Utiliser un pour la boucle pour créer une variable de boucle x. Cette variable sera utilisée pour parcourir les éléments de la liste.
7. Imprimez les valeurs de la liste sur la console.
8. Fin du corps de la boucle for.
9. Fin du corps de la fonction main().

C++ Fonctions de liste

Voici les fonctions std::list courantes :

Constructeurs

Voici la liste des fonctions fournis par le En tête de fichier:

• Constructeur par défaut std::list::list() - Il crée une liste vide, avec zéro élément.
• Constructeur de remplissage std::list::list()- Il crée une liste avec n éléments et attribue une valeur de zéro (0) à chaque élément.
• Constructeur de plage std::list::list()- crée une liste avec de nombreux éléments compris entre le premier et le dernier.
• Constructeur de copie std::list::list()- Il crée une liste avec une copie de chaque élément contenu dans la liste existante.
• Constructeur de déplacement std::list::list()- crée une liste avec les éléments d'une autre liste en utilisant la sémantique de déplacement.
• Constructeur de liste d'initialisation std::list::list() - Il crée une liste avec les éléments d'une autre liste en utilisant la sémantique de déplacement.

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

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête iostream pour utiliser ses fonctions.
2. Incluez le fichier d'en-tête de liste pour utiliser ses fonctions.
3. Incluez l'espace de noms std dans le code pour utiliser ses classes sans l'appeler.
4. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
5. Créez une liste vide nommée l.
6. Créez une liste nommée l1 avec un ensemble de 3 entiers.
7. Créez une liste nommée l2 avec tous les éléments de la liste nommée l1, du début à la fin.
8. Créez une liste nommée l3 en utilisant la sémantique de déplacement. La liste l3 aura le même contenu que la liste l2.
9. Imprimez la taille de la liste nommée l sur la console à côté d'un autre texte.
10. Imprimez du texte sur la console.
11. Créez un itérateur nommé et utilisez-le pour parcourir les éléments de la liste nommée l2.
12. Imprime les éléments de la liste nommée l2 sur la console.
13. Imprimez du texte sur la console.
14. Créez un itérateur nommé et utilisez-le pour parcourir les éléments de la liste nommée l3.
15. Imprime les éléments de la liste nommée l3 sur la console.
16. Le programme doit renvoyer de la valeur une fois terminé.
17. Fin du corps de la fonction main().

Propriétés du conteneur

Voici la liste des propriétés du conteneur :

Insérer dans une liste

Il existe différentes fonctions permettant d'insérer des valeurs dans une liste. Prenons l'exemple suivant :

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

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête de l'algorithme pour utiliser ses fonctions.
2. Incluez le fichier d'en-tête iostream pour utiliser ses fonctions.
3. Incluez le fichier d'en-tête de liste pour utiliser ses fonctions.
4. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
5. Créez une liste nommée my_list avec un ensemble de 4 entiers.
6. Insérez l'élément 11 au début de la liste nommée my_list.
7. Insérez l'élément 18 à la fin de la liste nommée my_list.
8. Créez un itérateur et utilisez-le pour trouver l'élément 10 de la liste my_list.
9. Utilisez une instruction if pour déterminer si l'élément ci-dessus a été trouvé ou non.
10. Insérez l'élément 21 avant l'élément ci-dessus s'il a été trouvé.
11. Fin du corps de l'instruction if.
12. Utilisez une boucle for pour créer une variable de boucle x. Cette variable sera utilisée pour parcourir les éléments de la liste.
13. Imprimez les valeurs de la liste sur la console.
14. Fin du corps de la boucle.
15. Fin du corps de la fonction main().

Les éléments qui figurent dans une liste peuvent tout aussi facilement en être retirés.

Suppression d'une liste

Il est possible de supprimer des éléments d'une liste. La fonction erase() permet de supprimer un élément ou une plage d'éléments d'une liste.

• Pour supprimer un seul élément, il vous suffit de passer une position entière. L'élément sera supprimé.
• Pour supprimer une plage, vous devez fournir les itérateurs de début et de fin. Illustrons cela.

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

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête de l'algorithme pour utiliser ses fonctions.
2. Incluez le fichier d'en-tête iostream pour utiliser ses fonctions.
3. Incluez le fichier d'en-tête de liste pour utiliser ses fonctions.
4. Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
5. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
6. Créez une liste nommée my_list avec un ensemble de 4 entiers.
7. Imprimez du texte sur la console.
8. Utilisez une boucle for pour créer une variable de boucle x. Cette variable sera utilisée pour parcourir les éléments de la liste.
9. Imprimez les valeurs de la liste sur la console.
10. Fin du corps de la boucle for.
11. Créez un itérateur i qui pointe vers le premier élément de la liste.
12. Utilisez la fonction effacer() pointée par l'itérateur i.
13. Imprimez du texte sur la console.
14. Utilisez une boucle for pour créer une variable de boucle x. Cette variable sera utilisée pour parcourir les éléments de la liste.
15. Imprimez les valeurs de la liste sur la console. Cela vient après la suppression.
16. Fin du corps de la boucle for.
17. Le programme doit renvoyer une valeur une fois terminé.
18. Fin du corps de la fonction main().

FAQ