LISTE AVEC LES CLASSES C++

/**************************************************

Les noeuds que j'utiliserai seront pour des entier.

**************************************************/
class Noeud 
{
  friend class Liste; //cette ligne est bien important pour le concept. En fait elle dit que
                      //la classe 'Liste' est son ami, donc la classe 'Liste' va pouvoir utiliser
                      //ces Méthode et Attribut même s'ils sont privé. PS:(1)bas de page.
  //Par défaut tout se qui se trouve dans la classe est privé, mais cela n'empèche pas de faire
  //mieu voir que pour les méthodes/attributs suivante c'est le cas.
  private:
    Noeud ( int unNombre ); //un constructeur pour un nouveau noeud qui prend en paramètre un nombre.
    Noeud ( const Noeud & unNoeud ); //on peut aussi créer un noeud avec un Noeud déjà existant.

    int m_iMonNombre; //le nombre que le noeud contient.
    Noeud * m_pNoeudSuivant; //un pointeur vers le noeud suivant.PS:(2)bas de page.
};
/**************************************************

La liste appartir duquel on peut ajouter des noeud.
ps: cette classe est l'ami de la classe Noeud, donc
    elle peut utilisé les choses définies plus haut.

Note: Pour une première lecture, ne vous occupé pas
      du constructeur 'Liste(const Liste &uneListe)'
      et de l'operator = . Vous comprendrez plus tard.
      De toute façons, ceux-ci ne sont pas si important.
      Et p-e dure à comprendre...

**************************************************/
class Liste
{
  public:
    Liste(); //constructeur par défault de la classe 'Liste' le plus important.
    Liste( const Liste & uneListe ); // ce constructeur ne sert que si l'on veut copier une liste
                                     // déja existante dans une autre.
    ~Liste();//Descrtructeur de la classe. (important car il faut bien supprimer tout les noeuds que 
             //l'on a créé pour libérer l'espace mémoire.

    const Liste & operator = ( const Liste & uneListe ); //Redéfinition de l'opérateur '='
    void Ajouter( int leNombre ); //une méthode pour ajouter un nouveau 'Noeud' à la liste.
    bool Suivant(); //méthode pour faire avancer le pointeur du noeud courant d'un noeud.
    void Premier(); //Pour mettre le pointeur du noeud courant au premier élément
    int NoeudCourant(); //Pour retourner la valeur(int) du noeud courant.
    void Vider(); //Méthode pour vider la liste.

  private:
    Noeud * m_pPremierNoeud; // pointeur sur sur le premier noeud de la liste.
    Noeud * m_pNoeudCourant; // pointeur pour pouvoir se déplacer dans la liste.
};

//Ce constructeur de la classe noeud reçoit en paramètre un
// nombre car la liste va contenir des nombres.
//On initialise l'attribut 'int' de la classe avec la valeur passé
// en paramètre, puis on initialise le pointeur vers le noeud suivant
// à zéro
Noeud :: Noeud( int unNombre )
{
  m_iMonNombre = unNombre;
  m_pNoeudSuivant = 0; //on aurais aussi pu remplacer 0 par 'NULL'
}

//Ce constructeur de la classe reçois en paramètre un noeud.
//On initialise l'attribut 'int' avec la valeur que le noeud contient.
//Ps: j'ai mit un '&' pour dire que l'on passe la référence de l'objet Noeud
// et pas de faire une copie. Cette référence est constante, on ne peut pas la modifier.
Noeud :: Noeud( const Noeud & unNoeud )
{
  m_iMonNombre = unNoeud.m_iMonNombre;
  m_pNoeudSuivant = 0;
}


/**********************************************

  Auteur : Alberd_m

  but: L'implémentation de la classe Liste

**********************************************/

//Ce constructeur de la classe Liste met les attributs à zéro.
Liste :: Liste()
{
  m_pPremierNoeud = 0; // on peut toujours remplacer le 0 par 'NULL' si l'on le désir.
  m_pNoeudCourant = 0;
}

//PS: PAS IMPORTANT POUR COMPRENDRE LES LISTE...
//Sauter ceci pour une première lecture.
//Ce constructeur permet de créer la liste avec une liste existante passé en paramètre.
//'* this' signifie l'objet présent/courant(la Liste) va égaler la liste passé en paramètre.
//Pour que ce constructeur marche, nous devons redéfinir le = car le = ne peut pas marcher
// de base avec un objet.
Liste :: Liste( const Liste & uneListe )
{
  * this = uneListe;
}

//Le destructeur de la classe Liste est très importante. Nous devons libérer l'espace mémoire
// que nous avons utilisé en créant plusieurs noeud.
//Le destructeur appele la méthode Vider().
//PS: il appele la méthode vider car il met utile de faire un méthode avec la procédure pour 
// libéré la mémoire car je vais l'utilisé plusieurs fois.
Liste::~Liste()
{
  Vider();
}

//PS: PAS IMPORTANT POUR COMPRENDRE LES LISTE...
//Saute ceci pour une première lecture. 
//On redéfini l'opérateur = pour pouvoir copier un objet.
//On commence par vider la liste, puis on copie les attributs voulu.
//La méthode = va faire en sorte que les attributs se copie donc avec l'attribut
// passé en paramètre on copie les pointeurs dans la classe courante.
//ps: le return sert a pouvoir faire comme ( x = y = 1) x va == 1 car y =1 return 1 a sont tour.
const Liste & Liste :: operator = ( const Liste & uneListe )
{
  Vider();

  m_pPremierNoeud = uneListe.m_pPremierNoeud; // copie le pointeur du premier noeud
  m_pNoeudCourant = uneListe.m_pNoeudCourant; // copie le pointeur du noeud courant

  return * this; //retourn l'objet courant.
}

//la méthode ajouter ajoute un nouveau noeud(un entier) à la liste.
//Créer un pointeur sur un nouveau noeud avec la valeur du nombre passé en paramètre.
//Si c'est le premier élément copie l'adresse créer dans le pointeur du premier Noeud.
//sinon va au dernier noeud et copie l'adresse du pointeur créer dans l'attribut
// noeud suivant pour pouvoir les lier.
void Liste :: Ajouter( int leNombre )
{
  Noeud * punNouveauNoeud = new Noeud( leNombre );
  if ( m_pPremierNoeud  == 0 )
  {
    m_pPremierNoeud =  punNouveauNoeud;
  }
  else
  {
    while( Suivant() ){} //Suivant() retourne vrai tant que l'attribut noeudSuivant pointe sur un
                         // Noeud valide(ben différent de 0) Si il retourne false(stop la boucle)
                         // puis l'attribut de la classe liste NoeudCourant va pointer sur le 
                         // dernier noeud. Donc en fin de liste.
    m_pNoeudCourant->m_pNoeudSuivant = punNouveauNoeud;
    
  }
  m_pNoeudCourant = m_pPremierNoeud; //on remet le noeud courant au début.
}

//La méthode Suivant() retourne un booléen.
//Elle retourne vrai si l'attribut NoeudSuivant du noeud courant est pointe sur un noeud 
//valide(différend de 0)
//Dans le cas contraire retourne faux.(donc nous serions à la fin de la liste.)
bool Liste :: Suivant()
{
  if ( m_pNoeudCourant == 0 ) //Si le noeud courant pointe sur un noeud non valide. 
                              //met le noeud courant au premier noeud.
  {
    m_pNoeudCourant = m_pPremierNoeud;
  }
  if ( m_pNoeudCourant->m_pNoeudSuivant != 0 ) 
  {
    m_pNoeudCourant = m_pNoeudCourant->m_pNoeudSuivant;
    return true;
  }
  else
  {
    return false;
  }
}

//La méthode Premier() met le noeud courant au premier noeud.
void Liste :: Premier()
{
  m_pNoeudCourant = m_pPremierNoeud;
}

//La méthode NoeudCourant() retourne la valeur du noeud courant si le noeud courant
//pointe sur un noeud valide.
//Sinon j'ai decider de faire retourner -1.
int Liste :: NoeudCourant()
{
  if ( m_pNoeudCourant != 0 )
  {
    return m_pNoeudCourant->m_iMonNombre;
  }
  else
  {
    return -1;
  }
}

//La méthode Vider() vide la liste de ces noeuds.
//elle créer un noeud pour pouvoir garder une référence sur le prochain noeud.
//supprime le noeud puis remet le noeud suivant au premier noeud.
void Liste :: Vider()
{
  Noeud * tmpNoeudSuivant;
  do //fait cette boucle tant que le premier noeud va être valide.
  {
    tmpNoeudSuivant = m_pPremierNoeud->m_pNoeudSuivant;
    delete m_pPremierNoeud;
    m_pPremierNoeud = tmpNoeudSuivant;
    
  }while( m_pPremierNoeud != 0 );
  m_pPremierNoeud = m_pNoeudCourant = 0;

}

//Par la suite on peut utilisé la classe.

int main()
{
  Liste * uneListe = new Liste(); //Créer un pointeur sur une nouvelle liste.
  int i = 0;
  uneListe->Ajouter(5); //ajoute à la liste la valeur 5
  uneListe->Ajouter(15);//ajoute à la liste la valeur 15...
  uneListe->Ajouter(25);
  do //pour faire afficher les éléments dans la liste.
  {
    cout << i << " : " << uneListe->NoeudCourant() << endl;
    i++;
  }while(uneListe->Suivant());

  system("PAUSE"); //une pause.

  //Parti deux:
  //Pour tester l'opérateur = que j'ai redéfini.
  Liste * uneAutreListe = uneListe;
  uneAutreListe->Premier(); //remet la liste au début et fait afficher par la suite a lécran.
  do
  {
    cout << i << " : " << uneListe->NoeudCourant() << endl;
    i++;
  }while(uneListe->Suivant());

  system("PAUSE");
  return 0;
}