Présentation des fonctions de std::list

Soyez le premier à donner votre avis sur cette source.

Vue 24 087 fois - Téléchargée 307 fois

Description

Ce code présente sur un exemple toutes les fonctions membres de list (STL).

Source / Exemple :


//#define VC6									// Pour l'utilisation de VC6 décommenter la ligne (certaines parties du code ne seront pas compilées)

// INCLUDE
#include <list>									// Inclue la classe liste
#include <iostream>								// Pour l'utilisation de cout
#include <cassert>								// Pour les assertions

// VARIABLE GLOBALE
std::list<int> MaListe;							// Déclaration de ma liste comme une liste d'entiers

// PROTOTYPE
void afficher();								// Fonction d'affichage de MaListe sur std::cout
void reinitialiser();							// Réinitialise la liste avec des valeurs prédéfinies
// Predicate
// Définition d'un predicate qui renvoie vrai si la fonction est impaire
template <class T> class est_impaire : public std::unary_function<T, bool> 
{
public:
   bool operator( ) ( T& val ) 
   {
   return ( val % 2 ) == 1;		// Si le nombre est paire, le modulo 2 est égale à 0, l'égalité n'est pas vérifié et donc la valeur false est renvoyée
   }
};

// MAIN
void main()
{
	reinitialiser();
	afficher();

	std::list<int> MaListe2;					// Déclaration de ma liste comme une liste d'entiers
	MaListe2.push_back(43500);
	MaListe2.push_back(4);
	MaListe2.push_back(36);

	// FONCTION ASSIGN
	// (1) Efface le contenu de la liste et lui attribue celle d'une autre liste ou sous liste (comprise entre les 2 itérateurs)
	// (2) Efface le contenu de la liste et lui attribue une même valeur un certain nombre de fois
	std::cout << "ASSIGN (1)" << std::endl;
	MaListe.assign(MaListe2.begin(), MaListe2.end());
	afficher();
//	MaListe.assign(MaListe2.end(), MaListe2.begin());			// Cas d'erreur (inversion des 2 itérateurs)
//	afficher();													// La liste est remplie d'un élément contenant "n'importe quoi"
	std::list<int>::iterator Debut2=MaListe2.begin();		
	Debut2++;													// Debut2 est un pointeur sur le deuxième élément
	MaListe.assign(Debut2, MaListe2.end());
	afficher();
	std::cout << "ASSIGN (2)" << std::endl;
	MaListe.assign(5,10);										// Mettre la valeur "10" 5 fois dans la liste
	afficher();
	reinitialiser();

	// FONCTION BACK
	// (1) Renvoie une référence modifiable sur le dernier élément
	// (2) Renvoie une référence non modifiable sur le dernier élément
	std::cout << "BACK (1)" << std::endl;
	int& i = MaListe.back( );
	std::cout << i << std::endl;
	i=999;
	afficher();													// A partir du moment où j'obtiens une référence modifiable, je modifie i et la modification se répercute sur le dernier élément de la liste
	std::cout << "BACK (2)" << std::endl;
	const int& j = MaListe.back();								// Comme j'ai mis le mot clé const, je vais obtenir une référence non modifiable
	// j = 888;													// -----> Je ne peux pas compiler cette ligne de code. j est en quelque sorte en lecture seule. 
																// Si on ne veut pas modifier le dernier élément de la liste on a intérêt à utiliser cette référence constante
	std::cout << j << std::endl;
	reinitialiser();

	// FONCTION BEGIN
	// (1) Renvoie un itérateur modifiable sur le premier élémént
	// (2) Renvoie un itérateur non modifiable sur le premier élément
	std::cout << "BEGIN (1)" << std::endl;
	std::list<int>::iterator UnIterateur;						// Déclaration d'un itérateur sur une liste d'entiers
	UnIterateur = MaListe.begin();								// On lui attribue l'adresse du premier élément de la liste
	std::cout << *UnIterateur << std::endl;						// Affichage du contenu du pointeur

  • UnIterateur = 777; // Modification du premier élément
std::cout << *UnIterateur << std::endl; // Affichage du contenu du pointeur UnIterateur++; // On pointe maintenant sur le deuxième élément std::cout << *UnIterateur << std::endl; // Affichage du contenu du pointeur std::cout << "BEGIN (2)" << std::endl; std::list<int>::const_iterator UnIterateurConstant; // Déclaration d'un itérateur constant sur une liste d'entiers UnIterateurConstant = MaListe.begin(); std::cout << *UnIterateurConstant << std::endl; // Affichage du contenu du pointeur // *UnIterateurConstant = 666; // ---> Ca ne compile pas, le contenu du pointeur est protégé UnIterateurConstant++; // Ca par contre, je peux. Je me balade donc sur les éléments de la liste, sans pouvoir les modifier std::cout << *UnIterateurConstant << std::endl; // Affichage du contenu du pointeur reinitialiser(); // FONCTION CLEAR // Vide la liste std::cout << "CLEAR" << std::endl; MaListe.clear(); afficher(); reinitialiser(); // FONCTION EMPTY // Dit si la liste est vide ou non std::cout << "EMPTY" << std::endl; if(MaListe.empty()!=true) std::cout << "Cette liste n'est pas vide" << std::endl; MaListe.clear(); if(MaListe.empty()==true) std::cout << "Cette liste est vide (on vient de faire un clear)" << std::endl; reinitialiser(); // FONCTION END // Equivalent de BEGIN pour la fin de la liste ; attention end() pointe après le dernier élément de la liste // FONCTION ERASE // (1) Efface un élément // (2) Efface une série d'éléments std::cout << "ERASE (1)" << std::endl; MaListe.erase(MaListe.begin()); // Efface le premier élément afficher(); reinitialiser(); std::cout << "ERASE (2)" << std::endl; MaListe.erase(MaListe.begin(),MaListe.end()); // Efface du premier au dernier élément (équivalent d'un clear) afficher(); reinitialiser(); // FONCTION FRONT // Equivalent BACK pour le début de la liste // GET_ALLOCATOR // Récupère le système d'allocation utilisée par une liste pour par exemple fabriquer une nouvelle liste sur la base de cette allocation std::cout << "GET_ALLOCATOR" << std::endl; std::list<int> ListeAllocationCommeMaListe(MaListe.get_allocator() ); // INSERT // Insère de nouveaux éléments dans la liste std::cout << "INSERT (1)" << std::endl; std::list<int>::iterator IteEndroitInsere=MaListe.end(); IteEndroitInsere--; // On va insérer le nouvel élément à l'avant dernière position MaListe.insert(IteEndroitInsere,42); afficher(); std::cout << "INSERT (2)" << std::endl; MaListe.insert(IteEndroitInsere,4,1); // On insère 4 fois 1 au niveau de l'itérateur IteEndroitInsere afficher(); std::cout << "INSERT (3)" << std::endl; MaListe.insert(IteEndroitInsere,MaListe2.begin(),--MaListe2.end()); // On insère tous les éléments de la liste 2 sauf le dernier au niveau de l'itérateur IdeEndroitInsere afficher(); reinitialiser(); // MAX_SIZE // Renvoie la taille maximale que peut prendre la liste std::cout << "MAX_SIZE" << std::endl; std::cout << "Taille maximale de la liste : " << MaListe.max_size() << std::endl; // MERGE // Fusionne des listes et efface les éléments qui ont été insérés, éventuellement ordonne les listes (à condition que les deux listes à fusionner soient déjà ordonnées et de la même façon (par ex. ascendant)) std::cout << "MERGE (1)" << std::endl; MaListe2.clear(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); MaListe.merge(MaListe2); // Merge sans deuxième argument : par défaut, ordre ascendant (ici cela ne va pas marcher car les listes ne sont pas ordonnées) assert(MaListe2.empty()); // Assertion, après le MERGE, MaListe2 est vide afficher(); std::cout << "MERGE (2)" << std::endl; reinitialiser(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); MaListe.merge( MaListe2, std::greater<int>( ) ); // On spécifie l'ordonnement : ici du plus grand au plus petit (descendant) assert(MaListe2.empty()); // MERGE AVEC DEUX LISTES DEJA ORDONNEES afficher(); reinitialiser(); MaListe.sort(); // Trie les éléments dans l'ordre ascendant afficher(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); MaListe2.sort(); MaListe.merge(MaListe2); assert(MaListe2.empty()); afficher(); // Cette fois-ci la liste fusionnée est ordonnée reinitialiser(); // POP_BACK // Efface le dernier élément de la liste afficher(); MaListe.pop_back(); afficher(); reinitialiser(); // POP_FRONT // Pareil que pop_back pour le premier élément de la liste // PUSH_BACK // Insère un élément à la dernière position de la liste afficher(); MaListe.push_back(42); afficher(); reinitialiser(); // PUSH_FRONT // Pareil que push_back pour la première position de la liste // RBEGIN // Permet de parcourir la liste inversée // (1) Renvoie un itérateur modifiable sur le premier élémént de la liste inversée // (2) Renvoie un itérateur non modifiable sur le premier élément std::cout << "RBEGIN (1)" << std::endl; std::list<int>::reverse_iterator UnRIterateur; // Déclaration d'un reverse itérateur sur une liste d'entiers UnRIterateur = MaListe.rbegin(); // On lui attribue l'adresse du premier élément de la liste inversée std::cout << *UnRIterateur << std::endl; // Affichage du contenu du pointeur
  • UnRIterateur = 777; // Modification du premier élément
std::cout << *UnRIterateur << std::endl; // Affichage du contenu du pointeur UnRIterateur++; // On pointe maintenant sur le deuxième élément std::cout << *UnRIterateur << std::endl; // Affichage du contenu du pointeur reinitialiser(); std::cout << "RBEGIN (2)" << std::endl; #ifndef VC6 std::list<int>::const_reverse_iterator UnRIterateurConstant; // Déclaration d'un itérateur constant sur une liste d'entiers UnRIterateurConstant = MaListe.rbegin(); std::cout << *UnRIterateurConstant << std::endl; // Affichage du contenu du pointeur // *UnRIterateurConstant = 666; //---> Ca ne compile pas, le contenu du pointeur est protégé UnRIterateurConstant++; // Ca par contre, je peux. Je me balade donc sur les éléments de la liste inversée, sans pouvoir les modifier std::cout << *UnRIterateurConstant << std::endl; // Affichage du contenu du pointeur reinitialiser(); #endif // REMOVE // Supprime de la liste tous les éléments de la valeur spécifiée std::cout << "REMOVE" << std::endl; afficher(); MaListe.remove(38); afficher(); reinitialiser(); // REMOVE_IF // Supprime de la liste tous les éléments de la valeur vérifiant l'affirmation (predicate) // En clair : supprime si <condition vérifiée> #ifndef VC6 std::cout << "REMOVE_IF" << std::endl; afficher(); MaListe.remove_if( est_impaire<int>() ); afficher(); // Le 73 de la liste a bien disparu reinitialiser(); #endif // REND // Permet de parcourir la liste inversée en fournissant un pointeur après le dernier élément de la liste // (1) Renvoie un itérateur modifiable sur le dernier élémént de la liste inversée // (2) Renvoie un itérateur non modifiable sur le dernier élément std::cout << "REND (1)" << std::endl; std::list<int>::reverse_iterator UnRIterateurEnd; // Déclaration d'un reverse itérateur sur une liste d'entiers UnRIterateurEnd = MaListe.rend(); // On lui attribue l'adresse du premier élément de la liste inversée std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur : rend une valeur "fausse" puisque nous sommes en dehors de la liste inversée UnRIterateurEnd--; // Modification du dernier élément (de la liste inversée) std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur UnRIterateurEnd--; // On pointe maintenant sur le deuxième élément std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur UnRIterateurEnd--; // On pointe maintenant sur le troisième et dernier élément std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur reinitialiser(); #ifndef VC6 std::cout << "REND (2)" << std::endl; std::list<int>::const_reverse_iterator UnRIterateurConstantEnd; // Déclaration d'un itérateur constant sur une liste d'entiers UnRIterateurConstantEnd = MaListe.rend(); UnRIterateurConstantEnd--; std::cout << *UnRIterateurConstantEnd << std::endl; // Affichage du contenu du pointeur // *UnRIterateurConstant = 666; //---> Ca ne compile pas, le contenu du pointeur est protégé UnRIterateurConstantEnd--; // Ca par contre, je peux. Je me balade donc sur les éléments de la liste inversée, sans pouvoir les modifier std::cout << *UnRIterateurConstantEnd << std::endl; // Affichage du contenu du pointeur reinitialiser(); #endif // RESIZE // Redéfinit la taille de la liste // (1) En indiquant la nouvelle taille // (2) En indiquant la nouvelle taille et la valeur des éléments à ajouter le cas échéant std::cout << "RESIZE (1)" << std::endl; MaListe.resize(10); // Nouvelle taille de la liste : 10 afficher(); MaListe.resize(2); afficher(); std::cout << "RESIZE (2)" << std::endl; MaListe.resize(10,67); afficher(); MaListe.resize(4,68); // Deuxième paramètre superflu, puisque la nouvelle taille impose une réduction de la liste afficher(); reinitialiser(); // REVERSE // Inverse la liste std::cout << "REVERSE (1)" << std::endl; afficher(); MaListe.reverse(); afficher(); reinitialiser(); // SIZE // Renvoie la taille de la liste std::cout << "SIZE (1)" << std::endl; std::cout << "La taille de MaListe est : " << MaListe.size() << std::endl; // SORT // Ordonne la liste // (1) En ordre croissant // (2) Suivant un ordre personnalisé std::cout << "SORT (1)" << std::endl; afficher(); MaListe.sort(); afficher(); reinitialiser(); std::cout << "SORT (2)" << std::endl; MaListe.sort( std::greater<int>( ) ); // Ordre décroissant afficher(); // SPLICE // Insère les éléments d'une liste dans une autre, en les supprimant de la liste d'origine // (1) Insère toute la liste // (2) Insère l'élément de la liste spécifié par l'itérateur // (3) Insère les éléments de la liste compris entre deux itérateurs std::cout << "SPLICE (1)" << std::endl; MaListe2.clear(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); std::list<int>::iterator IteMaListe=MaListe.begin(); IteMaListe++; MaListe.splice(IteMaListe,MaListe2); assert(MaListe2.empty()); afficher(); std::cout << "SPLICE (2)" << std::endl; reinitialiser(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); IteMaListe=MaListe.end(); std::list<int>::iterator IteListe2=MaListe2.end(); IteListe2--; IteListe2--; MaListe.splice(IteMaListe,MaListe2,IteListe2); afficher(); reinitialiser(); std::cout << "SPLICE (3)" << std::endl; reinitialiser(); MaListe2.clear(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); IteMaListe=MaListe.end(); IteListe2=MaListe2.end(); IteListe2--; IteListe2--; MaListe.splice(IteMaListe,MaListe2,IteListe2,MaListe2.end()); afficher(); reinitialiser(); // SWAP // (1) Echange les éléments de deux listes // (2) Echange les éléments de deux listes (fonction amie) std::cout << "SWAP (1)" << std::endl; MaListe2.clear(); MaListe2.push_back(90); // Remplissage de MaListe2 MaListe2.push_back(25); MaListe2.push_back(39); MaListe2.push_back(70); MaListe.swap(MaListe2); afficher(); std::cout << "SWAP (2)" << std::endl; swap(MaListe,MaListe2); afficher(); // UNIQUE // (1) Supprime les éléments identiques adjacents // (2) Supprime les éléments adjacents vérifiant la même affirmation std::cout << "UNIQUE (1)" << std::endl; MaListe.push_back(73); afficher(); MaListe.unique(); afficher(); std::cout << "UNIQUE (2)" << std::endl; MaListe.push_front(38); MaListe.push_back(73); afficher(); std::not_equal_to<int> mypred; MaListe.unique(mypred); afficher(); } // AFFICHER // Affiche tous les éléments de MaListe void afficher() { std::cout << "***" << std::endl; if(!MaListe.empty()) { std::list<int>::iterator IterateurListe; // Construction d'un itérateur pour parcourir les éléments de la liste for(IterateurListe=MaListe.begin();IterateurListe!=MaListe.end();IterateurListe++) { std::cout << "Valeur de l'iterateur : " << (*IterateurListe) << std::endl; // L'itérateur est un pointeur sur un élément de la liste. Pour avoir son contenu il faut donc mettre la petite étoile devant. } } else { std::cout << "La liste est vide" << std::endl; } std::cout << "***" << std::endl; } // REINITIALISER // Réinitialise la liste avec une série de nombre void reinitialiser() { MaListe.clear(); MaListe.push_back(38); // On remplit la liste avec différents éléments par des "push_back" MaListe.push_back(26); // Chaque push_back ajoute un élément à la liste en le plaçant à la dernière position MaListe.push_back(73); }

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

yoyo269
Messages postés
1403
Date d'inscription
lundi 23 février 2004
Statut
Membre
Dernière intervention
11 janvier 2009
3 -
Ce qui aurait été bien c'est de mettre un petit exemple avec un petit zip. ;)
Mais j'en demande peut-être un peu trop.
Sinon bon boulot.

YOYO, @+.
guilhemmartincpp
Messages postés
29
Date d'inscription
mercredi 17 septembre 2003
Statut
Membre
Dernière intervention
9 janvier 2008
-
Salut Yoyo,

je t'ai rajouté donc un .zip, un projet construit sous .Net. J'en ai profité pour rajouter une (magnifique) capture d'écran.

@+
Guilhem.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.