std ::list en C++ avec exemple

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

En C++, std::list fait référence à un conteneur de stockage. Le std:list vous permet d'insérer et de supprimer des éléments de n'importe où. Le std ::list est implémenté sous la forme d'une liste à double lien. Cela 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 morceaux de mémoire. Les informations nécessaires à l'accès séquentiel aux données sont stockées dans un conteneur. Le std ::list peut se développer et se réduire des deux côtés selon les besoins pendant l'exécution. Un répartiteur interne remplit automatiquement les besoins de stockage.

Dans ce didacticiel C++, vous apprendrez :

• Qu'est-ce qu'une std::list ?
• Pourquoi utiliser std::list ?
• Syntaxe de liste
• Fonctions de liste C++
• Constructeurs
• Propriétés du conteneur
• Insérer dans une liste
• Suppression d'une liste

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.
• Std::list fonctionne également mieux avec des algorithmes qui effectuent de telles opérations de manière intensive.

Syntaxe de la liste

Pour définir le std ::list, nous devons importer le fichier d'en-tête . 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 d'allocation.

  Cela utilise le modèle de classe d'allocateur par défaut. Il dépend de la valeur et utilise un modèle d'allocation de mémoire simple.

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 de la boucle for a.
9. Fin du corps de la fonction main().

Fonctions de liste C++

Voici les fonctions courantes de std::list :

Fonction Description insert()Cette fonction insère un nouvel élément avant la position vers laquelle pointe l'itérateur.push_back()Cette fonction ajoute un nouvel élément à la fin de la liste.push_front()Elle ajoute un nouvel élément au début de la liste.pop_front()Elle supprime la liste first item.size()Cette fonction détermine le nombre d'éléments de la liste.front()To détermine les premiers éléments de la liste.back()To détermine le dernier élément de la liste.reverse()It inverse les éléments de la liste.merge()It fusionne deux listes triées.

Constructeurs

Voici la liste des fonctions fournies par le fichier d'en-tête  :

• Constructeur par défaut std ::list ::list () - Il crée une liste vide, c'est-à-dire 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 dans la plage du premier au dernier.
• Copier le constructeur 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'initialisateur 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é it et utilisez-le pour parcourir les éléments de la liste nommée l2.
12. Afficher 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é it et utilisez-le pour parcourir les éléments de la liste nommée l3.
15. Afficher les éléments de la liste nommée l3 sur la console.
16. Le programme doit renvoyer une valeur en cas de réussite.
17. Fin du corps de la fonction main().

Propriétés du conteneur

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

Propriété Description Les conteneurs SequenceSequence ordonnent leurs éléments dans une séquence linéaire stricte. Les éléments sont accessibles par leur position dans la séquence. Liste doublement liée 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 de 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 dans 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 for a.
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 erase() 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 passez les itérateurs de début et de fin. Démontrons 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 :

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 erase() 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 en cas de réussite.
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ù à temps constant.
• Il est implémenté comme un lien double
• 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 dans 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 développer 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 erase().