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);
}
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.