begin process at 2012 02 12 08:33:59
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Tutoriaux

 > STL : LA CLASSE LIST

STL : LA CLASSE LIST


 Information sur la source

Note :
8 / 10 - par 2 personnes
8,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Tutoriaux Niveau :Initié Date de création :09/02/2002 Date de mise à jour :09/02/2002 02:16:49 Vu :10 309

Auteur : tibur

Ecrire un message privé
Commentaire sur cette source (6)
Ajouter un commentaire et/ou une note

 Description

La classe liste est une liste chainée. Elle permet des ajouts en tete, en queue de liste, et bien sur, dans la liste elle meme. Petit introduction : utilisation de l'algorithme de tri de la STL.

Source

  • //Ce container est une liste chainee d'elements.
  • //Nous ne disposons plus d'un acces indexe,
  • //mais par contre, des insertions
  • //et suppression sont possibles.
  • #include <stdio.h>
  • #include <list>
  • int main(int argc, char ** argv){
  • //**********************************************
  • // TECHNIQUE DE BASE
  • //**********************************************
  • //commencons par creer une liste d'entiers :
  • std::list<int> listInt;
  • //nous pouvons ajouter des valeurs en queue de liste
  • listInt.push_back( 1 );
  • listInt.push_back( 2 );
  • listInt.push_back( 3 );
  • //ou en tete de liste
  • listInt.push_front( 4 );
  • listInt.push_front( 5 );
  • listInt.push_front( 6 );
  • //pour parcourir cette liste, nous avons besoin d'un iterateur.
  • //On peut voir cet objet comme un pointeur sur le type element.
  • //declarons un iterateur sur une liste d'entiers
  • std::list<int>::iterator iter;
  • //on assigne iter au debut de la liste
  • iter = listInt.begin();
  • //on itere ...
  • for( ; iter != listInt.end(); iter++ ){
  • printf("%i\n", *iter); // *iter est du type element, donc du type int
  • }
  • //**********************************************
  • // UTILISATION AVANCEE
  • //**********************************************
  • //comme pour les tableaux, nous pouvons creer des liste d'element de
  • //n'importe quel type... ex : une liste de flottants
  • // std::list<float> listFloat;
  • //suppression d'un element de la liste :
  • //on choisis le 2em element de la liste
  • iter = listInt.begin();
  • iter++;
  • //on le supprime
  • listInt.erase( iter );
  • //Attention : iter a ete modifie par la fonction erase
  • //on affiche la liste
  • printf("\nApres suppression du 2 em element\n");
  • for(iter = listInt.begin(); iter != listInt.end(); iter++ )
  • printf("%i\n", *iter);
  • //on va ajouter un element en 2em position :
  • iter = listInt.begin();
  • iter++;
  • //on ajoute l'element :
  • listInt.insert(iter, -2);
  • //on affiche la liste
  • printf("\nApres ajout de -2 en 2em position\n");
  • for(iter = listInt.begin(); iter != listInt.end(); iter++ )
  • printf("%i\n", *iter);
  • //on trie la liste (cf remarques)
  • listInt.sort();
  • //on affiche la liste
  • printf("\nApres tri de la liste\n");
  • for(iter = listInt.begin(); iter != listInt.end(); iter++ )
  • printf("%i\n", *iter);
  • //on vide la liste
  • listInt.clear();
  • //on test si elle est bien vide
  • if (listInt.empty()){
  • printf("\nListe videe\n", *iter);
  • }
  • else{
  • printf("\nHum, j'y crois pas de trop !\n", *iter);
  • }
  • return 0;
  • }
  • //neiger@ifrance.com
//Ce container est une liste chainee d'elements. 
//Nous ne disposons plus d'un acces indexe, 
//mais par contre, des insertions 
//et suppression sont possibles.

#include <stdio.h>
#include <list>
int main(int argc, char ** argv){

	//**********************************************
	//	TECHNIQUE DE BASE														
	//**********************************************
	
		//commencons par creer une liste d'entiers :
	std::list<int> listInt;
	
		//nous pouvons ajouter des valeurs en queue de liste
	listInt.push_back( 1 );
	listInt.push_back( 2 );
	listInt.push_back( 3 );

		//ou en tete de liste
	listInt.push_front( 4 );
	listInt.push_front( 5 );
	listInt.push_front( 6 );

		//pour parcourir cette liste, nous avons besoin d'un iterateur. 
		//On peut voir cet objet comme un pointeur sur le type element.

		//declarons un iterateur sur une liste d'entiers
	std::list<int>::iterator iter;

		//on assigne iter au debut de la liste
	iter = listInt.begin();

		//on itere ...
	for( ; iter != listInt.end(); iter++ ){
		printf("%i\n", *iter);			// *iter est du type element, donc du type int
	}


	//**********************************************
	//	UTILISATION AVANCEE 												
	//**********************************************

		//comme pour les tableaux, nous pouvons creer des liste d'element de
		//n'importe quel type... ex : une liste de flottants
		// std::list<float> listFloat;

		//suppression d'un element de la liste :

		//on choisis le 2em element de la liste
	iter = listInt.begin();	
	iter++;

		//on le supprime
	listInt.erase( iter );	
		//Attention : iter a ete modifie par la fonction erase 

		//on affiche la liste
	printf("\nApres suppression du 2 em element\n");
	for(iter = listInt.begin(); iter != listInt.end(); iter++ )
		printf("%i\n", *iter);			
	

		//on va ajouter un element en 2em position :
	iter = listInt.begin();
	iter++;

	//on ajoute l'element :
	listInt.insert(iter, -2);

			//on affiche la liste
	printf("\nApres ajout de -2 en 2em position\n");
	for(iter = listInt.begin(); iter != listInt.end(); iter++ )
		printf("%i\n", *iter);			
	
	
		//on trie la liste (cf remarques)
	listInt.sort();

		//on affiche la liste
	printf("\nApres tri de la liste\n");
	for(iter = listInt.begin(); iter != listInt.end(); iter++ )
		printf("%i\n", *iter);	

		//on vide la liste
	listInt.clear();

		//on test si elle est bien vide
	if (listInt.empty()){
		printf("\nListe videe\n", *iter);	
	}
	else{
		printf("\nHum, j'y crois pas de trop !\n", *iter);	
	}
	

	return 0;	
}
//neiger@ifrance.com 

 Conclusion

Tout commentaire est bienvenu


 Sources du même auteur

Source avec Zip TIMER
ECRITURE / LECTURE EN C++
Source avec Zip BIG SIGNED INTEGER
SMART POINTER
DE L'IMPORTANCE DES ASSERT

 Sources de la même categorie

LISTER FICHIERS ET RÉPERTOIRES (MULTIPLATEFORME) par christophedlr
UTILISATION DES TYPELIST EN C++ par wyden
Source avec Zip Source avec une capture QCSSCOMPRESSOR par alphaone
AFFICHAGE D'UN TRIANGLE ISOCELE par nabche
Source avec Zip GESTION D'UNE BIBLOTHEQUE par leclerro19

Commentaires et avis

Commentaire de premier_primo_first le 24/11/2004 16:48:51

merci j'avais besoin d'1 code simple comme celui là :)

Commentaire de maincpp le 07/01/2005 19:06:50

est ce qu'on peut utiliser des listes circulaires avec la classe list

Commentaire de sithlords le 19/10/2005 14:39:27

des quoi ?

Commentaire de MadM@tt le 16/11/2007 17:09:04 8/10

Merci, simple et clair

Commentaire de mmox le 11/03/2008 07:51:09

Merci  beaucoup  .
peut-on encore utiliser iter  aprés la suppression  du deuxième élément  ? Et si oui vers quoi pointe-t-il ?

Commentaire de tibur le 12/03/2008 09:37:19

En fait, le mieux serait de faire :
iter = listInt.erase(iter);

Selon la doc de la stl (http://www.sgi.com/tech/stl/), iter pointe alors sur l'élément suivant de la liste, ou sur listInt.end() si l'on vient de supprimer le dernier élément.

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,468 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales