GESTION D'UNE CLASSE D'ÉLÈVES

#include <iostream.h>
#include <fstream.h> // pour declarer  les 2 classes ostream et istream
#include <string.h>
#include <stdio.h>


class Eleve
{
      protected:
                char Nom[10+1];
                char Prenom[10+1];
                char Matricule[10+1];
      public:
             Eleve(char*No="", char*Pre="", char *Mat="");

             virtual void Affiche(); //definition de fonctions virtuelles
             virtual void Saisir();

             Eleve*pSuivant; // pointeur vers l'objet suivant
		
	// redefinition des operateurs de flux en liaison avec la librairie iostream
        // déclarée en friend pour acceder a tous les membres de la classe Eleve grace a un
	// pointeur de la classe Eleve*
  friend ostream& operator<<(ostream& out,Eleve*v); // objet de type ostream pour ecrire 
                                                    //dans un fichier
  friend istream& operator>>(istream& in,Eleve*v);// objet de type istream pour lire un  
                                                  // fichier
};

// la classe Ecole gere une liste d'objet Eleve
class Ecole
{
      private :
              Eleve*pPremier;
              Eleve*pCourant;
              public :
                     Ecole();
                     virtual ~Ecole();
                     void Ajouter(Eleve *pEle);
                     void AfficheTout();
                     void Enregistrer();
                     void Recuperer();
};
// définition d'un constructeur pour la classe Eleve
Eleve::Eleve(char *No, char *Pre, char *Mat)
{
	// initialisation des chaines
         strcpy(Nom, No);
         strcpy(Prenom, Pre);
         strcpy(Matricule, Mat);
         pSuivant = NULL;
}

// fonction qui affiche a l'ecran toutes les donnees membres
void Eleve::Affiche()
{
	// affiche le contenu avec alignement a gauche
     cout.setf(ios::left, ios::adjustfield);
     cout<< " Nom : ";
	// width permet de definir le nombre de caractere maxi
     cout.width(10);
     cout<<Nom;
     cout<< " Prenom : ";
     cout.width(10);
     cout<<Prenom;
     cout<< " Matricule : ";
     cout.width(10);
     cout<<Matricule;
     cout<<endl;
}

void Eleve::Saisir()
{
     cout<< " Nom : ";
	// getline() permet de saisir des chaines de caracteres avec des espaces
	// sizeof(Nom) correspond a la taille de la chaine (Nom[10+1])
     cin.getline(Nom, sizeof(Nom) );
     cout<< " Prenom : ";
     cin.getline(Prenom, sizeof(Prenom) );
     cout<< " Matricule : ";
     cin.getline(Matricule, sizeof(Matricule) );
} 

// objet de type ostream pour ecrire dans un  fichier                                             
// l'operateur << redéfini au niveau de la classe Eleve est utilise pour sauvegarder les
// données membres de chaque objet en séparant chaque valeur par un ';'             
ostream& operator <<  (ostream& out, Eleve* v)
{
         out<< v->Nom       << ';';
         out<< v->Prenom    << ';';
         out<< v->Matricule << ';';
         
         return out;
}
// objet de type istream pour lire un fichier
// redefinition de l'operateur de flux >> pour la recuperation de donnees
istream& operator >> (istream& in, Eleve* v)
{
   //récuperation des donnees du Fichier (voir fonction Recuperer()) jusqu'au caractere ';'
         in.getline( v->Nom, sizeof(v->Nom),';' );
         in.getline( v->Prenom, sizeof(v->Prenom),';' );
         in.getline( v->Matricule, sizeof(v->Matricule),';' );
         
         return in;
}

// définition d'un constructeur pour la classe Ecole
Ecole::Ecole()
{
              pPremier=NULL;
              pCourant=NULL;
              Recuperer();
}

// fonction appelee par le destructeur de la classe Ecole
void Ecole::Enregistrer()
{
	//destrcution du fichier ECOLE.TXT
     remove("ECOLE.TXT");
	// ouverture en ecriture grace a la creation de l'objet ofstream
     ofstream Fichier("ECOLE.TXT");
	// test d'ouverture du fichier
     if (!Fichier) return;
     
     Eleve*pTemp;// pointeur vers l'objet Eleve
     pTemp=pPremier;
   
	// boucle qui permet de parcourir la liste chainee afin de sauvegarder chaque objet
        //de cette liste 
     while(pTemp)
     {
                 Fichier<< pTemp ;
                 pTemp=pTemp->pSuivant;
     }
}

// fonction pour lire le fichier ECOLE.TXT qui sera cree.
void Ecole::Recuperer()
{
	//creation de l'objet ifstream pourlire le fichier 
     ifstream Fichier("ECOLE.TXT");
	// test pour savoir si l'ouverture du fichier a reussi sinon on quitte la fonction
     if (!Fichier) return;
     
     Eleve *pTemp; //pointeur vers l'objet pTemp
     
	// boucle qui permet de balayer le fichier jusqu'a la fin (!Fichier.eof())
     while (!Fichier.eof())
     {
           pTemp = new Eleve;// creation d'un objet de type Eleve
           Ajouter(pTemp);// puis ajouter a Ecole grace a la fonction Ajouter()
           Fichier>> pTemp;//initialisation de l'objet pTemp par le flux Fichier
           Fichier>> ws;    // enlever les espaces eventuels
     }
}
 
// fonction Ajouter avec objet de type Eleve      
void Ecole::Ajouter(Eleve *pEle)
{
	// condition si pointeur est sans valeur
     if (pPremier==NULL)
     {
	//initialisation des pointeurs grace a l'objet
               pPremier = pEle;
               pCourant = pEle;
     }
     else
     {
         pCourant->pSuivant = pEle;
         pCourant = pCourant->pSuivant;
     }
}

// fonction qui permet d'afficher la totalite du fichier
void Ecole::AfficheTout()
{
     Eleve *pTemp;
     pTemp=pPremier;
 
	// boucle qui appelle la fonction Affiche() pour afficher chaque objet du fichier a
        // la fois  
     while(pTemp)
     {
                 pTemp->Affiche();
                 pTemp=pTemp->pSuivant;
     }
}

// destructeur de la classe Ecole
Ecole::~Ecole()
{
	// appel de la fonction Enregistrer avant appel du destructeur
 		Enregistrer();
   			if (pPremier)
     			delete pPremier;
}

   // fonction main()
int main()
{
	// création d'un objet Cours de type Ecole
    Ecole Cours;
	// initialistion des pointeurs
    Eleve *pEle=NULL;
    int Option = 0;
 
// boucle pour le choix des options   
    while (1)
    {
          cout<< "\nChoisissez une option de menu \n";
          cout<< "(1-Creation, 2-Afficher Ecole, 0-Pour quitter): ";
		//recuperation de votre choix
          cin>>Option;
  		//annule le \n        
          cin.ignore();
          
          switch(Option)
          {
           case 1 : pEle = new Eleve;
                    pEle->Saisir();
                    Cours.Ajouter(pEle);
                    break;

           case 2 : Cours.AfficheTout();
           break;

           case 0 : return 0;

           default : cout<< "\nChoix invalide\a\n";
           continue;
           }
    }
}