PRÉSENTATION DES FONCTIONS DE STD::LIST

//#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);
}