std :: liste dans C++ avec exemple

Pourquoi utiliser std :: list ?

Voici les raisons d'utiliser std::List :

• Le std::list se compare mieux aux autres conteneurs de séquence comme le tableau et le vecteur.
• Ils ont de meilleures performances pour insérer, déplacer et extraire des éléments depuis n’importe quelle position.
• Le std::list fait également mieux avec les algorithmes qui effectuent de telles opérations de manière intensive.

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 d'élément contenu. Vous pouvez remplacer T par n'importe quel type de données, même les types définis par l'utilisateur.
• Alloc – Définit le type de l'objet allocateur. Celui-ci utilise le modèle de classe allocateur par défaut. Il dépend de la valeur et utilise un modèle simple d'allocation de mémoire.

Exemples 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 :

Explication du code :

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. 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.
7. Imprimez les valeurs de la liste sur la console.
8. Fin du corps du pour la boucle.
9. Fin du corps de la fonction main().

C++ Fonctions de liste

Voici les fonctions std::list courantes :

Fonction	Description
insérer()	Cette fonction insère un nouvel élément avant la position vers laquelle pointe l'itérateur.
repousser()	Cette fonction ajoute un nouvel élément à la fin de la liste.
push_front()	Il ajoute un nouvel élément au début de la liste.
pop_front()	Il supprime le premier élément de la liste.
Taille()	Cette fonction détermine le nombre d'éléments de la liste.
de face()	To détermine les premiers éléments de la liste.
dos()	To détermine le dernier élément de la liste.
inverser ()	Il inverse les éléments de la liste.
fusionner()	Il fusionne deux listes triées.

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 :

Explication du code :

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 :

Propriétés	Description
Séquence	Les conteneurs de séquence ordonnent leurs éléments dans une séquence linéaire stricte. Les éléments sont accessibles par leur position dans la séquence.
Liste à double chaînage	Chaque élément contient des informations sur la façon de localiser les éléments précédents et suivants. Cela permet un temps constant pour les opérations d’insertion et de suppression.
Conscient de l'allocateur	Un objet allocateur est utilisé pour modifier dynamiquement la taille du stockage.

Insérer dans une liste

Il existe différentes fonctions que nous pouvons utiliser pour insérer des valeurs dans une liste. Démontrons ceci :

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 :

Explication du code :

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().

Suppression d'une liste

Il est possible de supprimer des éléments d'une liste. La fonction effacer() vous 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 transmettez les itérateurs de début et de fin. Montrons-le.

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 :

Explication du code :

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().

Résumé

• Le std::list est un conteneur de stockage.
• Il permet l'insertion et la suppression d'éléments de n'importe où et à temps constant.
• Il est implémenté sous forme de double lien
• Les données std::list sont accessibles de manière bidirectionnelle et séquentielle.
• std::list ne prend pas en charge l'accès aléatoire rapide. Cependant, il prend en charge l’accès séquentiel depuis toutes les directions.
• Vous pouvez disperser les éléments de liste de std::list dans différents morceaux de mémoire.
• Vous pouvez réduire ou étendre std::list des deux côtés selon vos besoins pendant l'exécution.
• Pour insérer des éléments dans std::list, nous utilisons la fonction insert().
• Pour supprimer des éléments de la std::list, nous utilisons la fonction Eraser().