Liste avec les classes c++

Soyez le premier à donner votre avis sur cette source.

Vue 15 260 fois - Téléchargée 391 fois

Description

Bonjour, depuis peu, j'ai un travail à faire dans le cadre de mon cours de programmation en c++. Le travail que j'avais à faire était un peu plus compliqué, mais je voulais bien comprendre avant de mit lancer, donc j'ai chercher des sources qui montrais comment bien faire avec les classes. Je n'ai pas trouver de sources bien expliquer. Je vais tenter de vous faire voir ce que j'y ai comprit.

J'aimerais bien que vous me disiez comment vous trouvez à votre tour.

Source / Exemple :


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

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

Conclusion :


Vous pouvez télécharger le projet pour mieux voir tout le processus.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
24
Date d'inscription
dimanche 5 juin 2005
Statut
Membre
Dernière intervention
23 novembre 2009

salut jp je t'adore !!!!
Messages postés
4
Date d'inscription
mercredi 23 mai 2007
Statut
Membre
Dernière intervention
11 novembre 2008

Comment vous trouvez mon petit bout de code? j'aimerais bien avoir quelque commentaire si sa vous chante.

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.