Gestion d'une classe d'élèves

Commenter

Contenu du snippet

Bonjour,
voila j'ai voulu reprendre le code d'un autre post (http://www.cppfrance.com/code.aspx?id=31259#)qui est en C et le reecrire en C++ voila le nouveau code, il y a moins de fonctions que dans l'original mais comme je debute je progresse pas a pas ( je ne vous cache pas que je me suis inspire d'exemples existants...;))
Voila d'autres fonctions seront ajoutees plus tard.

Source / Exemple : 


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

Conclusion :


code compilé sous dev-cpp sans bug. il manque certaines fonctionnalites comme supprimer un eleve et on peut creer plusieur fois le meme eleve.

A voir également

S'inscrire maintenant

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.