vous voulez du code en voici ^^ :)
(intégralité du code)
ce code sert a créer et géré une liste chainé. a partir d'un élément on a accé a son suivant et son précédent, et j'utilise des itérateur qui pointe vers un élément pour parcourir la liste :

"liste.h" :


#ifndef LISTE_H
#define LISTE_H
#include <string>
using namespace std;

template <class T> class Element;
template <class R> class Iterateur;

template <class S> class Liste{
private:
// pointeurs vers le premier et le dernier element
Element<S>* premier;
Element<S>* dernier;

public:
//constructeurs
Liste<S>();

//constructeur par recopie
Liste<S>(const Liste<S> &);

//fonction membre copy utilisé par le constructeur par recopie et par l'operateur d'affectation
void copy(const Liste &);

//destructeur
~Liste();

//fonction membre free utilisé par le destructeur et par l'operateur d'affectation
void free();

Liste& operator=(const Liste&);

// ajouter s a la fin de la liste
void ajouter(const S& s);

// ajouter s avant la position pos
void inserer(const Iterateur<S>& pos, const S& s);

// supprimer l'element a la position pos
void supprimer(Iterateur<S>& pos);

// la premiere position
Iterateur<S> debut() const;

// la fin de la liste (apres la derniere position)
Iterateur<S> fin() const;




};


template<class R> class Iterateur
{
public:
// constructeur
Iterateur();

// retourne la valeur dans cette position
R& operator*() const;



// avance a la position suivante
void operator++();

void operator++(int);

// recule a la position precedente
void operator--();

void operator--(int);

// compare deux iterateurs
bool operator==(const Iterateur& b) const;

bool operator!=(const Iterateur& b) const;

private:
// pointeur vers l'element courant
Element<R>* position;

// pointeur vers le dernier element de la liste
Element<R>* dernier;

template <class S> friend class Liste;
};

#endif





"liste.cc" :

#include "liste.h"
#include <string>
#include <iostream>
using namespace std;

template <class T> class Element
{
public:
// constructeur
Element(const T& s);

private:
string valeur;

// pointeurs vers les voisins
Element<T>* precedent;
Element<T>* suivant;

template <class S> friend class Liste;
template <class R> friend class Iterateur;
};


template <class T> Element<T>::Element(const T& s)
{ valeur = s;
precedent = suivant = NULL;
}


template<class R> Iterateur<R>::Iterateur()
{ position = dernier = NULL;
}


template<class R> R& Iterateur<R>::operator*() const
{ return position->valeur;
}



template<class R> void Iterateur<R>::operator++()
{ position = position->suivant;
}

template<class R> void Iterateur<R>::operator++(int inutile)
{ position = position->suivant;
}

template<class R> void Iterateur<R>::operator--()
{ if (position == NULL) // fin de la liste
position = dernier;
else
position = position->precedent;
}

template<class R> void Iterateur<R>::operator--(int)
{ if (position == NULL) // fin de la liste
position = dernier;
else
position = position->precedent;
}

template<class R> bool Iterateur<R>::operator==(const Iterateur& b) const
{ return position == b.position;
}

template<class R> bool Iterateur<R>::operator!=(const Iterateur& b) const
{ return position != b.position;
}


Liste::Liste()
{ premier = dernier = NULL;
}
template<class S> Liste<S>::Liste()
{ premier = dernier = NULL;
}

template<class S> Liste<S>::Liste(const Liste<S> &l){

copy(l);

}

template<class S> void Liste<S>::copy(const Liste<S> &l){
premier = dernier = NULL;
Iterateur<S> pos;
for (pos =(l.debut()); pos!=(l.fin()); pos++){
ajouter(*pos);
}
}

template<class S> Liste<S>::~Liste(){
free();
}

template<class S> void Liste<S>::free(){
Iterateur<S> pos;
for (pos =debut(); pos!=fin(); pos++){
delete(pos.position);
}
}

template<class S> Liste<S>& Liste<S>:: operator=(const Liste &l){
if(this !=&l){
free();
copy(l);
}
return *this;
}


template<class S> Iterateur<S> Liste<S>::fin() const
{ Iterateur<S> it;
it.position = NULL;
it.dernier = dernier;
return it;
}

template<class S> void Liste<S>:: ajouter(const S& s){
Element<S> *e=new Element<S>(s);

if(dernier==NULL){
dernier=premier=e;
}
else {
e->precedent =dernier;
dernier->suivant=e;
dernier=e;
}
}

template<class S> void Liste<S>:: inserer(const Iterateur<S> &pos, const S& s){
Element<S> *e=new Element<S>(s);


if(pos.position == premier){
premier->precedent=e;
e->precedent=NULL;
e->suivant=premier;
premier=e;
}
else if(pos.position==NULL){

dernier->suivant=e;
e->suivant=NULL;
e->precedent=dernier;
dernier=e;
}
else{
e->precedent =pos.position->precedent;
e->suivant=pos.position;
(pos.position)->precedent->suivant=e;
(pos.position)->precedent=e;

}
}

template<class S> void Liste<S>::supprimer(Iterateur<S>& pos){
if(pos.position==NULL){
cout<<"\n la liste est vide ! ou la position indiquée est NULL :\n rien à supprimer\n"<<endl;
}
else if(pos.position == premier){
Iterateur<S> tmp=pos;
++pos;
premier->suivant->precedent=NULL;
premier=premier->suivant;
delete tmp.position;

}
else if(pos.position == dernier){
Iterateur<S> tmp=pos;
++pos;
dernier->precedent->suivant=NULL;
dernier=dernier->precedent;
delete tmp.position;
}
else{
Iterateur<S> tmp=pos;
++pos;
(tmp.position)->precedent->suivant=(tmp.position)->suivant;
(tmp.position)->suivant->precedent=(tmp.position)->precedent;
delete tmp.position;
}
}





"test_list.cc" (main)


#include <string>
#include <list>
#include "liste.h"
#include <iostream>
using namespace std;

int main(){

Liste<int> personnel;
Iterateur<int> pos;

// ajouter 4 elements
personnel.ajouter(12);
personnel.ajouter(17);
personnel.ajouter(15);
personnel.ajouter(27);

// test du constructeur par recopie
Liste<int> toto(personnel);

// inserer un element a la quatrieme position
pos = toto.debut();

pos++;
pos++;
pos++;


toto.inserer(pos, 77);


// supprimer l'element a la deuxieme position
pos = toto.debut();
pos++;
toto.supprimer(pos);

// afficher tous les elements
for (pos = toto.debut(); pos!=(toto.fin()); ++pos)
cout << *pos << endl;

//test de l'operateur d'affectation
Liste<int> toto2;
toto2=toto;

cout << "\n\ndeuxième affichage :"<< endl;

for (pos = toto2.debut(); pos!=(toto2.fin()); ++pos)
cout << *pos << endl;


// personnel.~Liste();
// toto.~Liste();
// toto2.~Liste();

return 0;
}




voila le tout compiler grace a ce makefile simplissime :


liste: liste.o test_list.o
g++ -o liste liste.cc test_list.cc liste.h

liste.o: liste.cc liste.h
g++ -o liste.o -c liste.cc liste.h

test_list.o: test_list.cc liste.cc liste.h
g++ -o test_list.o -c test_list.cc liste.h




^^ bonne lecture