C++ v8

#include <iostream>
#include<vector>
#include<iomanip>
#include <windows.h>
#include <conio.h>
using namespace std;
class Personne {
protected:
int id;
string nom;
string prenom;
string mail;
public:
Personne(){}
Personne(int id,string nom,string prenom,string mail);
friend ostream& operator<<(ostream& ,const Personne&);
//getters
int getid(){return id;}
string getNomPersonne(){ return nom;}
string getPrenomPersonne(){return prenom;}
string getMailPersonne(){return mail;}
//setters
void setNomP(string nomp){nom=nomp;}
void setPrenomP(string prenomp){prenom=prenomp;}
void setMailP(string mailp){mail=mailp;}
};
// Constructeur de l'objet Personne :
Personne::Personne(int id,string nom,string prenom,string mail)
{
this->id=id;
this->nom=nom;
this->prenom=prenom;
this->mail=mail;
}
// surcharge de l op << pour Personne
ostream& operator<<(ostream& cout ,const Personne& p)

{
cout<<p.id<<","<<p.nom<<","<<p.prenom<<","<<p.mail<<endl;
return cout;
}
//--------------------------------------------------------------------------
class Etudiant : public Personne {

private:
int Num_insc;
public:
Etudiant(){};
Etudiant(int id,string nom,string prenom,string mail,int Num_insc);
friend ostream& operator<<(ostream& ,const Etudiant& );
int getNumInscc(){return Num_insc;}
};
// Constructeur de l'objet Etudiant :
Etudiant::Etudiant(int id,string nom,string prenom,string mail,int Num_insc):

Personne(id,nom,prenom,mail)
{
this->Num_insc=Num_insc;
}
// surcharge de l op << pour Etudiant
ostream& operator<<(ostream& cout ,const Etudiant& e)

{
cout<<e.id<<","<<e.nom<<","<<e.prenom<<","<<e.mail<<",";
cout<<e.Num_insc<<endl;
return cout;
}
//---------------------------------------------------------------------------------
----------
//Classe Enseignant :
class Enseignant : public Personne {

private:
int CNSS;
public:
Enseignant(){}
Enseignant(int id,string nom,string prenom,string mail,int CNSS);
friend ostream& operator<<(ostream& cout ,const Enseignant& e);
};
// Constructeur de l'objet Enseignant :
Enseignant::Enseignant(int id,string nom,string prenom,string mail,int

CNSS):Personne(id,nom,prenom,mail)
{
this->CNSS=CNSS ;
}
// surcharge de l op << pour Enseignant
ostream& operator<<(ostream& flux ,const Enseignant& e)

{
flux<<e.id<<","<<e.nom<<","<<e.prenom<<","<<e.mail<<",";
flux<<e.CNSS<<endl;
return flux;
}
//---------------------------------------------------------------------------------
--------
// Classe Matiere :
class Matiere{
protected:
string idMat;
string nomMat;
float coef;
Enseignant ens;
public:
Matiere(){}
Matiere(string idMat,string nomMat,float coef,Enseignant ens);
friend ostream& operator<<(ostream& cout ,const Matiere& m);
//Getters
string getidmat(){return idMat;}
float getcoef(){return coef;}
Enseignant getEns(){return ens;}
string getNomMatiere(){return nomMat;}
string getNomEns(){ return ens.getNomPersonne();}
//setters
void setNomM(string nom){nomMat=nom;}
void setCoefM(float coefm ){coef=coefm;}
void setEns(Enseignant e){ens=e;}
void setMatiereMailProf(string mail){ens.setMailP(mail);}
void setMatiereNomProf(string nom){ens.setNomP(nom);}
void setMatierePrenomProf(string prenom){ens.setPrenomP(prenom);}
void setMatiereProf(Enseignant e){ens=e;}
};
// Constructeur de l'objet Matiere :
Matiere::Matiere(string idMat,string nomMat,float coef,Enseignant ens)
{
this->idMat=idMat;
this->nomMat=nomMat;
this->coef=coef;
this->ens=ens;
}
// surcharge de l op << pour matiere

ostream& operator<<(ostream& cout ,const Matiere& m)
{
cout<<m.idMat<<","<<m.nomMat<<","<<m.coef<<","<<m.ens<<endl;
return cout;
}
//---------------------------------------------------------------------------------
----------------
// Classe Note :
class note {
private:
Matiere Mat;
Etudiant Etu;
int Note;
string Type;
public:
note(){}
note(Matiere MatAJ,Etudiant EtuAJ,int Note, string Type);
friend ostream& operator<<(ostream& cout ,const note& n);
//Getters
int getnote(){return Note;}
Matiere getmatiere(){return Mat;}
Etudiant getetudiant(){return Etu;}
string getType(){return Type;}
};
//Constructeur de l'objet note:
note::note(Matiere MatAJ,Etudiant EtuAJ,int Note, string Type)
{
Mat=MatAJ;
Etu=EtuAJ;
this->Note=Note;
this->Type=Type;
// surcharge de l op << pour note
ostream& operator<<(ostream& cout ,const note& n)

{
cout<<n.Mat<<","<<n.Etu<<","<<n.Note<<","<<n.Type<<endl;
return cout;
}
//---------------------------------------------------------------------------------
---------------
// fonction Moymat
float Moymat(vector <note> tnote,string idmat,int idEtu)

{
int nb=0;
float somme=0;
for(int i=0;i<tnote.size();i++)
{
if((tnote[i].getmatiere().getidmat()==idmat)&&
(tnote[i].getetudiant().getid()==idEtu))
{
somme=somme+tnote[i].getnote() ;
nb=nb+1;
}
}
return somme/nb;
}
//---------------------------------------------------------------------------------
--------------------
//Classe GroupeModule :
class GroupeModule {
private:
string idGM;
string nomGM;
float coefGM;
vector <Matiere> ListMat ;
public:
GroupeModule(){}
GroupeModule(string idGM,string nomGM,float coefGM, vector <Matiere> ListMat);
friend ostream& operator<<(ostream& cout ,const GroupeModule& gm);
// fonction MoyGM :
float MoyGM(vector <note> tnote,int idEtu)
{ float somme=0;
int nb=0;
for(int i=0;i<ListMat.size();i++)
{ somme=(Moymat(tnote,ListMat[i].getidmat(),idEtu) *
ListMat[i].getcoef())+somme;
nb=nb+ListMat[i].getcoef();
}
return somme/nb;
}
//Getters
string getIdGm() {return idGM;}
string getNomGm() {return nomGM;}
float getcoef() {return coefGM;}
vector <Matiere> getListeMat(){return ListMat ;}
Matiere getElemntMat(int i) {return ListMat[i];}
//Setters
void setNomGm(string nom){nomGM=nom;}
void setCoefGm(float coef){coefGM=coef;}
//set matiere
void setGmNomMatiere(int k,string nomMatiere){ListMat[k].setNomM(nomMatiere);}
void setGmCoefMatiere(int k,float coefMatiere)
{ListMat[k].setCoefM(coefMatiere);}
void SetGmAjoutMat(Matiere y){ListMat.push_back(y);}
void SetGmSuppMat(int k) {vector <Matiere>::iterator
it;it=ListMat.begin();ListMat.erase(it+k);}
void SetGmMatiereMailProf(int j, string mail)
{ListMat[j].setMatiereMailProf(mail);}
void SetGmMatiereNomProf(int j, string nom)
{ListMat[j].setMatiereNomProf(nom);}
void SetGmMatierePrenomProf(int j, string prenom)
{ListMat[j].setMatierePrenomProf(prenom);}
void SetGmMatiereProf(int k,Enseignant e){ListMat[k].setMatiereProf(e);}
};
// Constructeur de l'objet GroupeModule :
GroupeModule::GroupeModule(string idGM,string nomGM,float coefGM,vector <Matiere>
ListMat)
{
this->idGM=idGM;
this->nomGM=nomGM;
this->coefGM=coefGM;
this->ListMat=ListMat;
}
// surcharge de l op << pour groupe module
ostream& operator<<(ostream& cout ,const GroupeModule& gm)

{
cout<<gm.idGM<<","<<gm.nomGM<<","<<gm.coefGM<<endl;
for(int i=0;i<gm.ListMat.size();i++) {cout<<gm.ListMat[i]<<endl;}
return cout;
}
//---------------------------------------------------------------------------------
------------
//Classe Groupe :
class Groupe {
private:
string IdGRP ;
string Niveau;
string Diplome;
string Specialite;
int NumG;
vector <GroupeModule> ListeModules;
vector <Etudiant> ListeEtudiants;
public:
Groupe(){}
Groupe(string IdGRP,string Niveau,string Diplome,string Specialite,int
NumG,vector <GroupeModule> ListeModules,vector <Etudiant> ListeEtudiants);
friend ostream& operator<<(ostream& cout ,const Groupe& g);
float Moyenne(int idEtu ,vector <note> tnote);

int trouve(int idEtu);
void AfficheMoy(int idEtu ,vector <note> tnote);
void AjoutEtu(Etudiant e);
void SuppEtu(int idetu);
int trouveNumInsc(int numEtu);
//Getters
string getidgroupe(){return IdGRP;}
vector <GroupeModule> getListeGM(){return ListeModules ; }
vector <Etudiant> getListeEtudiants(){return ListeEtudiants;}
GroupeModule getElementGM(int i){return ListeModules[i]; }
Etudiant getElementETU(int i){return ListeEtudiants[i]; }
string getDiplome(){return Diplome;}
//Setters
void SetNiveau(string x) { Niveau=x ;}
void SetDiplome(string x) { Diplome=x ;}
void SetSpecialite(string x) { Specialite=x ;}
void SetNumG(int x) { NumG=x ;}
void SetListeModule(vector <GroupeModule> x) { ListeModules=x;}
void SetListeEtudiant(vector <Etudiant> x) { ListeEtudiants=x ;}
//set gm
void SetlistAjoutgm(GroupeModule y){ListeModules.push_back(y);}
void setMAJnomGM(int i,string nom){ListeModules[i].setNomGm(nom);}
void setMAJcoefGM(int i,float coef){ListeModules[i].setCoefGm(coef);}
void SetlistSuppgm(int y) {vector <GroupeModule>::iterator
it;it=ListeModules.begin();ListeModules.erase(it+y);}
//set etu
void setMAJmailEtu(int j,string mail){ListeEtudiants[j].setMailP(mail) ;}
void setMAJnomEtu(int j,string nom){ListeEtudiants[j].setNomP(nom) ;}
void setMAJprenomEtu(int j,string prenom)
{ListeEtudiants[j].setPrenomP(prenom) ;}
//set matiere
void SetMajGroupeNomMatiere(int j,int k,string nomMatiere)
{ListeModules[j].setGmNomMatiere(k,nomMatiere);}
void SetMajGroupeCoefMatiere(int j,int k,float coefMatiere)
{ListeModules[j].setGmCoefMatiere(k,coefMatiere);}
void SetGroupGmAjoutMat(int j,Matiere y){ListeModules[j].SetGmAjoutMat(y);}
void SetGroupeGmSuppMat(int j,int k){ListeModules[j].SetGmSuppMat(k);}
void SetGroupeGmAjoutMatiere(int z,Matiere y)
{ListeModules[z].SetGmAjoutMat(y);}
void setGroupeGmSuppMat(int j,int k){ListeModules[j].SetGmSuppMat(k);}
void SetGroupeGmMatiereMailProf(int j,int k,string mail)
{ListeModules[j].SetGmMatiereMailProf(j,mail);}
void SetGroupeGmMatiereNomProf(int j,int k,string nom)
{ListeModules[j].SetGmMatiereNomProf(j,nom);}
void SetGroupeGmMatierePrenomProf(int j,int k,string prenom)
{ListeModules[j].SetGmMatierePrenomProf(j,prenom);}
void SetGroupeGmMatiereProf(int j,int k,Enseignant e)
{ListeModules[j].SetGmMatiereProf(k,e);}
};
void Groupe::SuppEtu(int idetu)

{
vector <Etudiant>::iterator it;
it=ListeEtudiants.begin();
int i=0;
while (i<ListeEtudiants.size())
{
if(ListeEtudiants[i].getid()==idetu)
{
ListeEtudiants.erase(it+i);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x02);
cout<<"Etudiant Supprimé"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
i++;
}
// recherche etudiant
int Groupe::trouve(int idEtu)
{
int trouv=-1;
int i=0;
while((trouv==-1)&&(i<ListeEtudiants.size()))
{
if(idEtu==ListeEtudiants[i].getid())
{
trouv=i;
return trouv;
}
i++;
}
return trouv;
}
//
int trouveNumInsc(vector <Etudiant> ListeEtudiants,int numEtu)

{
int trouv=-1;
int i=0;
while ((trouv==-1)&&(i<ListeEtudiants.size()))
{
if(numEtu==ListeEtudiants[i].getNumInscc())
{
trouv=i;
return trouv;
}
i++;
}
return trouv;
}
// moyenne etudiant
float Groupe::Moyenne(int idEtu ,vector <note> tnote)
{ float nb=0;
float somme=0;
if(trouve(idEtu)!=-1)
{
for(int i=0;i<ListeModules.size();i++)
{
somme=somme+
(ListeModules[i].MoyGM(tnote,idEtu)*ListeModules[i].getcoef());
nb=nb+ListeModules[i].getcoef();
}
return somme/nb;
}
else
{
return -1;
}
}
//Resultat
string Resultat(float x)
{ string m;
if (x==-1)
{ m="inexistant";
}
else if(0<x && x<10)
{
m="Ajourne";
}
else if(x>10)
{ SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x02);
m="Admis";
}
return m;
}
string Mention(float x)
{
string m;
if (x == -1)
{
m = "inexistant";
}
else if (0 < x && x < 10)
{
m = "";
}
else if (10 <= x && x < 12)
{
m = "Passable";
}
else if (12 <= x && x < 14)
{
m = "Assez bien";
}
else if (14 <= x && x < 16)
{
m = "Bien";
}
else if (16 <= x && x <= 20)
{
m = "Tres Bien";
}
else if (18 <= x && x <= 20)
{
m = "Excellent";
}
return m;
}
// affichage moyenne etudiant

void Groupe::AfficheMoy(int idEtu ,vector <note> tnote)
{
float x=Moyenne(idEtu ,tnote);
if (x!=-1)
{
cout<<x<<endl;
}
else {SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"etudiant n'existe
pas"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F); }
}
//ajouter etudiant
void Groupe::AjoutEtu(Etudiant e)
{
ListeEtudiants.push_back(e);
}
// constructeur de l'objet Groupe

Groupe::Groupe(string IdGRP,string Niveau,string Diplome,string Specialite,int
NumG,vector <GroupeModule> ListeModules,vector <Etudiant> ListeEtudiants)
{
this->IdGRP=IdGRP;
this->Niveau=Niveau;
this->Diplome=Diplome;
this->Specialite=Specialite;
this->NumG=NumG;
this->ListeModules=ListeModules;
this->ListeEtudiants=ListeEtudiants;
}
// surcharge de l op << pour groupe
ostream& operator<<(ostream& cout ,const Groupe& g)

{
cout<<g.IdGRP<<","<<g.Niveau<<","<<g.Diplome<<","<<g.Specialite<<","<<g.NumG<<endl;
for(int i=0;i<g.ListeModules.size();i++) {cout<<g.ListeModules[i]<<endl;}
for(int i=0;i<g.ListeEtudiants.size();i++) {cout<<g.ListeEtudiants[i]<<endl;}
return cout;
}
// Saisie
Etudiant saisiEtudiant()
{ int id;
string nom;
string prenom;
string mail;
int numinsc;
cout<<"Donner id etudiant"<<endl;
cin>>id;
cout<<"Donner le Nom de l'Etudiant"<<endl;

cin>>nom;
cout<<"Donner le Prenom de l'Etudiant"<<endl;

cin>>prenom;
cout<<"Donner le Mail de l'Etudiant"<<endl;

cin>>mail;
cout<<"Donner le Numero d'Inscription de l'Etudiant"<<endl;

cin>>numinsc;
Etudiant e(id,nom,prenom,mail,numinsc);
FILE *t;
t=fopen("archiveEtu.txt","a");
fprintf(t,"%d %s %s %s %d\n",id,nom,prenom,mail,numinsc);
fclose(t);
return e;
Enseignant saisieEns()
{
int id;
string nom;
string prenom;
string mail;
int cnss;
cout<<"Donner id Enseignant "<<endl;

cin>>id;
cout<<"Donner le Nom de l'Enseignant"<<endl;

cin>>nom;
cout<<"Donner le Prenom de l'Enseignant"<<endl;

cin>>prenom;
cout<<"Donner le Mail de l'Enseignant"<<endl;

cin>>mail;
cout<<"Donner le Numero d'Inscription de l'Enseignant"<<endl;

cin>>cnss;
FILE *t;
t=fopen("archiveENS.txt","a");
fprintf(t,"%d %s %s %s %d\n",id,nom,prenom,mail,cnss);
fclose(t);
Enseignant e(id,nom,prenom,mail,cnss);
return e;
Matiere saisiMatiere()
{
string idMat;
string nomMat;
float coef;
Enseignant ens;
cout<<"donner ID Matiere"<<endl;
cin>>idMat;
cout<<"Donner le Nome de Matiere"<<endl;

cin>>nomMat;
cout<<"Donner le Coef de la Matiere"<<endl;

cin>> coef;
ens=saisieEns();
Matiere m(idMat,nomMat,coef,ens);
return m;
}
note saisiNote()
{
Matiere m;
Etudiant e;
float n;
string type;
m=saisiMatiere();
e=saisiEtudiant();
do {
cout<<"donner la note sur 20 "<<endl;
cin>>n;
}while ((n>20) || (n<0));
do {
cout<<"donner le type de la note "<<endl;
cin>>type;
}while ((type!="ds") && (type!="tp")&&(type!="examen"));
note notee(m,e,n,type);
return notee;
GroupeModule saisiGM()
{
string idGM;
string nomGM;
float coefGM;
vector <Matiere> ListMat ;
int nbmat;
cout<<"donner ID du Groupe Module"<<endl;

cin>>idGM;
cout<<"donner le Nom du Groupe Module"<<endl;

cin>>nomGM;
cout<<"donner le Coef du Groupe Module"<<endl;

cin>>coefGM;
cout<<"donner le Nombre de Matiere dans ce Groupe Module"<<endl;

cin>>nbmat;
int i;
for(i=0;i<nbmat;i++)
{
ListMat.push_back(saisiMatiere());
}
GroupeModule gm(idGM,nomGM,coefGM,ListMat);
return gm;
}
int trouve(vector <Groupe> tgroupe,string idg)

{
int trouv=-1;
int i=0;
while((trouv==-1)&&(i<tgroupe.size()))
{
if(idg==tgroupe[i].getidgroupe())
{
trouv=i;
return trouv;
}
i++;
}
return trouv;
}
// Trouver list Module
int trouveGM(vector <GroupeModule>ListeModules,string idgm)

{
int trouv=-1;
int i=0;
while ((trouv==-1)&&(i<ListeModules.size()))
{
if(idgm==ListeModules[i].getIdGm())
{
trouv=i;
return trouv;
}
i++;
}
return trouv;
}
int trouveEtu(vector <Etudiant> ListeEtudiants,int idetu)

{
int trouv=-1;
int i=0;
while ((trouv==-1)&&(i<ListeEtudiants.size()))
{
if(idetu==ListeEtudiants[i].getid())
{
trouv=i;
return trouv;
}
i++;
}
return trouv;
}
// Ajouter Groupe
void AjouterGroupe(vector <Groupe> &tgroupe)

{
string idg;
string niveau;
string diplome;
string spec;
int numg;
int nbetu;
int nbmodule;
vector <GroupeModule> ListeModules;
vector <Etudiant> ListeEtudiants;
cout<<"donner id groupe"<<endl;
cin>>idg;
if(trouve(tgroupe,idg)!=-1)
{
cout<<"groupe existe
deja !"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
else
{ do {
cout<<"donner le Niveau du groupe"<<endl;
cin>>niveau;
} while((niveau!="1ere")&&(niveau!="2eme")&&(niveau!="3eme")&&(niveau!
="4eme")&&(niveau!="5eme"));
do {
cout<<"donner le Diplome du groupe"<<endl;
cin>>diplome;
} while((diplome!="Ing")&&(diplome!="Master")&&(diplome!
="Prepa")&&(diplome!="Licence")&&(diplome!="Doc"));
do {
cout<<"donner la Specialite du groupe"<<endl;
cin>>spec;
} while((spec!="Ing")&&(spec!="Master")&&(spec!="Prepa")&&(spec!
="Licence")&&(spec!="Doc"));
do {
cout<<"donner le Numero du groupe"<<endl;
cin>>numg;
} while((numg!=1)&&(numg!=2)&&(numg!=3));
FILE *t;
t=fopen("archiveGrp.txt","a");
fprintf(t,"%s %s %s %s %d \n",idg,niveau,diplome,spec,numg);
fclose(t);
do {
cout<<"donner le nbr d'etudiant dans ce groupe"<<endl;
cin>>nbetu;
}while(nbetu<0);
int i;
for(i=0;i<nbetu;i++)
{ Etudiant e=saisiEtudiant();
if(i==0)
{ListeEtudiants.push_back(e);}
else
{
if(trouveEtu(ListeEtudiants,e.getid())==-1)
{
ListeEtudiants.push_back(e);
}
else
{SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x04);
cout<<"ce groupe module existe deja"<<endl;}
}
}
do {
cout<<"donner le nbr de groupe Module dans ce groupe"<<endl;
cin>>nbmodule;
}while(nbmodule<0);
int j;
for(j=0;j<nbmodule;j++)
{
GroupeModule x=saisiGM() ;
if (j==0)
{
ListeModules.push_back(x);
}
else
{
if(trouveGM(ListeModules,x.getIdGm())==-1)
{
ListeModules.push_back(x);
}
else
cout<<"ce groupe module existe deja"<<endl;}
}
}
}
Groupe g( idg,niveau,diplome,spec,numg,ListeModules,ListeEtudiants);
tgroupe.push_back(g);
}
void SUPPGroupe(vector <Groupe> &tgroupe)

{
string idg;
cout<<"Donner l'Id du Groupe que vous souheitez Supprimer"<<endl;
cin>>idg;
vector <Groupe> ::iterator it;
it= tgroupe.begin();
int x=trouve(tgroupe,idg);
if(x==-1)
cout<<"groupe n'existe pas !"<<endl;
}
else
{
tgroupe.erase(it+x);
}
}
void MAJgroupeNiveau(vector <Groupe> &tgroupe)

{
string idg;
cout<<"donner l id du groupe a mettre a jour"<<endl;
cin>>idg;
if(x!=-1)
{
string niveau ;
do {
cout<<"Donner le Niveau du Groupe"<<endl;
cin>>niveau;
}while((niveau!="1ere")&&(niveau!="2eme")&&(niveau!="3eme")&&(niveau!
="4eme")&&(niveau!="5eme"));
tgroupe[x].SetNiveau(niveau);
}
else
{SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
cout<<"ce groupe n existe pas"<<endl;
}SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x04);
}
void MAJgroupeDilome(vector <Groupe> &tgroupe)
{
string idg;
cin>>idg;
if(x!=-1)
{
string diplome ;
do {
cout<<"Donner le diplome du Groupe"<<endl;
cin>>diplome;
}while((diplome!="Ing")&&(diplome!="Master")&&(diplome!="Prepa")&&(diplome!
="Licence")&&(diplome!="Doc"));
tgroupe[x].SetDiplome(diplome);
}
else
}SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
void MAJgroupeSpecialite(vector <Groupe> &tgroupe)
{
string idg;
cin>>idg;
if(x!=-1)
{
string spec;
do {
cout<<"donner la Specialite du groupe"<<endl;
cin>>spec;
} while((spec!="Inf")&&(spec!="Indus")&&(spec!="Meca"));
tgroupe[x].SetSpecialite(spec);
}
else
}
}
void MAJgroupeNumG(vector <Groupe> &tgroupe)
{
string idg;
cin>>idg;
if(x!=-1)
{
int numg ;
do {
cout<<"Donner le Numero du Groupe"<<endl;
cin>>numg;
}while((numg!=1)&&(numg!=2)&&(numg!=3));
tgroupe[x].SetNumG(numg);
}
else
}
}
int VerifGMdansTouTlesGroupes(vector <Groupe> tgroupe,string idg ,GroupeModule gm)

{
int i;
int trouv=-1;
for(i=0;i<tgroupe.size();i++)
{
if(tgroupe[i].getidgroupe()!=idg)
{ int j;
for (j=0;j<tgroupe[i].getListeGM().size();j++)
{
if((tgroupe[i].getElementGM(j).getIdGm()==gm.getIdGm())&&(tgroupe[i].getElementGM(j
).getcoef()!=gm.getcoef())&&(tgroupe[i].getElementGM(j).getNomGm()!=gm.getNomGm()))
{
trouv=0;
return trouv;
}
}
}
}
return trouv;
}
int ExisteGM(vector <Groupe> tgroupe,string idgm)

{
int trouv=-1;
int i=0;
int j=0;
while ((trouv==-1)&&(i<tgroupe.size()))
{
while ((trouv==-1)&&(j<tgroupe[i].getListeGM().size()))
{
if(idgm==tgroupe[i].getElementGM(j).getIdGm())
{
trouv=i;
return trouv;
}
j++;
}
i++;
}
return trouv;
}
// Verif Matiere
int VerifMatiereAll(vector <Groupe> tgroupe,string idm)
{
int i=0;
int trouv=-1;
{
int j=0;
while((trouv==-1)&&(j<tgroupe[i].getListeGM().size()))
{
int k=0;
while((trouv==-
1)&&(k<tgroupe[i].getElementGM(j).getListeMat().size()))
{
if(tgroupe[i].getElementGM(j).getElemntMat(k).getidmat()==idm)
{
trouv=0;
return trouv;
}
k++;
}
j++;
}
i++;
}
return trouv;
}
// MAJ Matiere
void MajMatNom(vector <Groupe> &tgroupe)

{
cout<<"donner l id de matiere a mettre a jour"<<endl;
string idm; cin>>idm;
if (VerifMatiereAll( tgroupe,idm)==-1)
cout<<"cette matiere n existe
pas"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
else
{
int somme=0;
string nomMatiere;
cout<<"donner le nouveau nom de matiere"<<endl;
cin>> nomMatiere;
for(int i=0;i<tgroupe.size();i++)
{
for(int j=0;j<tgroupe[i].getListeGM().size();j++)
{
for(int k=0;k<tgroupe[i].getElementGM(j).getListeMat().size();k++)
{
if(idm==tgroupe[i].getElementGM(j).getElemntMat(k).getidmat())
{
tgroupe[i].SetMajGroupeNomMatiere(j,k,nomMatiere);
somme=somme+1;
}
}
}
}
cout<<somme<<" mise a jour ont ete faites"<<endl;
}
}
void MajMatCoef(vector <Groupe> &tgroupe)

{
cout<<"donner l id de matiere a mettre a jour"<<endl;
cout<<"cette matiere n existe
}
else
{
float coefMatiere;
cout<<"donner le nouveau nom de matiere"<<endl;
cin>> coefMatiere;
int somme=0;
{
{
{
{
tgroupe[i].SetMajGroupeCoefMatiere(j,k,coefMatiere);
somme=somme+1;
}
}
}
cout<<somme<<" mise a jour ont ete faites"<<endl; }
}
void MajMatiereProf(vector <Groupe> &tgroupe)

{
cout<<"donner id matiere a mettre a jour"<<endl;
cout<<"cette matiere n existe pas"<<endl;
}
else
{
Enseignant e=saisieEns();
int somme=0;
{
{
{
{
tgroupe[i].SetGroupeGmMatiereProf(j,k,e);
somme=somme+1;
}
}
}
cout<<somme<<" mise a jour ont ete faite"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
}
void MajProfNom(vector <Groupe> &tgroupe)///////////////////////DONEEEEEEEEEEEEEE

{
int idp;
cout<<"donner l id du prof a mettre a jour"<<endl;
cin>>idp;
int somme=0;
string nomp;
cout<<"donner le nom du prof "<<endl;
cin>>nomp;
{
{
{
if(idp==tgroupe[i].getElementGM(j).getElemntMat(k).getEns().getid())
{
tgroupe[i].SetGroupeGmMatiereNomProf(j,k,nomp);
somme=somme+1;
}
}
}
}
void MajProfPrenom(vector <Groupe> &tgroupe)///////////////////////:DONEEEEEEEEEE

{
int idp;
cin>>idp;
int somme=0;
string nomp;
cout<<"donner le Prenom du prof "<<endl;
cin>>nomp;
{
{
{
{
tgroupe[i].SetGroupeGmMatierePrenomProf(j,k,nomp);
somme=somme+1;
}
}
}
}
void MajProfMail(vector <Groupe> &tgroupe)////////////////////////:DONEEEEEEEEEEE

{
int idp;
cin>>idp;
int somme=0;
string nomp;
cout<<"donner le mail du prof "<<endl;
cin>>nomp;
{
{
{
{
tgroupe[i].SetGroupeGmMatiereMailProf(j,k,nomp);
somme=somme+1;
}
}
}
}
void MajEtudiantNom(vector <Groupe> &tgroupe)

////////////DONEEEEEEEEEEEEEEEEEEEEEE
{
cout<<"donner id etudiant a mettre a jour"<<endl;
int id;cin>>id;
int i=0;
string Nom;
cout<<"donner le nom etudiant a mettre a jour"<<endl;
cin>>Nom;
int trouv=-1;
{
int j=0;
while((trouv==-1)&&(j<tgroupe[i].getListeEtudiants().size()))
{
if(tgroupe[i].getElementETU(j).getid()==id)
{
trouv=0;
tgroupe[i].setMAJnomEtu(j,Nom);
}
}
}
if(trouv==0){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x02);
cout<<"la mise a jour a ete
faite"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else{SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"aucune mise a jour n a ete
}
void MajEtudiantPrenom(vector <Groupe>

&tgroupe)////////////DONEEEEEEEEEEEEEEEEEEEEEE
{
int trouv=-1;
int id;cin>>id;
int i=0;
string PreNom;
cout<<"donner le Prenom etudiant a mettre a jour"<<endl;
cin>>PreNom;
{
int j=0;
{
{
trouv=0;
tgroupe[i].setMAJprenomEtu(j,PreNom);
}
}
}
if(trouv==0){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x02);
cout<<"la mise a jour a ete
else{SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x04);
cout<<"aucune mise a jour n a ete
}
void MajEtudiantMail(vector <Groupe> &tgroupe)

////////////DONEEEEEEEEEEEEEEEEEEEEEE
{
int trouv=-1;
int id;cin>>id;
int i=0;
string mail;
cout<<"donner le nom etudiant a mettre a jour"<<endl;
cin>>mail;
{
int j=0;
{
{
trouv=0;
tgroupe[i].setMAJmailEtu(j,mail);
}
}
}
if(trouv==0){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x02);cout<<"la mise a jour a ete
else{SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"aucune mise a jour n a ete
}
void MAJgmNom(vector <Groupe> &tgroupe)

{
string idgm;
cout<<"donner l id du grp module a mettre a jour"<<endl;
cin>>idgm;
int x=ExisteGM(tgroupe,idgm);
if (x==-1)
cout<<"ce groupe module n existe
}
else
{
int i;
for(i=0;i<tgroupe[x].getListeGM().size();i++)
{
if(idgm==tgroupe[x].getElementGM(i).getIdGm())
{ string nom;
cout<<"donner le nouveau nom"<<endl;
cin>> nom;
tgroupe[x].setMAJnomGM(i,nom);SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDL
E), 0x02);
cout<<"mise a jour nom
terminee"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
}
}
void MAJgmCoef(vector <Groupe> &tgroupe)

{
string idgm;
cout<<"donner l id du grp module a mettre a jour"<<endl;
cin>>idgm;
int x=ExisteGM(tgroupe,idgm);
if (x==-1)
cout<<"ce groupe module n existe
}
else
{
int i;
for(i=0;i<tgroupe[x].getListeGM().size();i++)
{
if(idgm==tgroupe[x].getElementGM(i).getIdGm())
{ float coef;
cout<<"donner le nouveau coef"<<endl;
cin>> coef;
tgroupe[x].setMAJcoefGM(i,coef);SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HAN
DLE), 0x02);
cout<<"mise a jour nom
terminee"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
}
}
int VerifGmMatiere(vector <Matiere> listMat, string idm)

{
int trouv=-1;
int i=0;
while ((trouv==-1)&&(i<listMat.size()))
{
if (idm==listMat[i].getidmat())
{
trouv=0;
return trouv;
}
i++;
}
return trouv;
}
void MajGmAjoutMat(vector <Groupe> &tgroupe)

{
string idgm;
cout<<"Donner l id du groupe module a mettre a jour "<<endl;
cin>>idgm;
if(ExisteGM(tgroupe,idgm)==-1)
cout<<" ce groupe module n existe
}
else
{
Matiere y=saisiMatiere();
{
{
{
if(VerifGmMatiere(tgroupe[i].getElementGM(j).getListeMat(),
y.getidmat())==-1)
{
tgroupe[i].SetGroupGmAjoutMat(j,y);
}
}
}
}
}
}
void AjoutMatALL(vector <Groupe> &tgroupe)

{
string idgm;
cout<<"Donner l id du groupe module dans leguel vous souhaitez ajouter la
matiere "<<endl;
cin>>idgm;
}
else
{
Matiere y=saisiMatiere();
{
{
{
if(VerifGmMatiere(tgroupe[i].getElementGM(j).getListeMat(),
y.getidmat())==-1)
{
tgroupe[i].SetGroupGmAjoutMat(j,y);
}
}
}
}
}
}
void MajGmSuppMat(vector <Groupe> &tgroupe)
{
string idgm;
cout<<"Donner l id du groupe module a mettre a jour "<<endl;
cin>>idgm;
}
else
{ cout<<"donner l id de matiere a supprimer"<<endl;
int somme=0;
{
for (int j=0;j<tgroupe[i].getListeGM().size();j++)
{
if(tgroupe[i].getElementGM(j).getIdGm()==idgm)
{
for(int k=0;k<tgroupe[i].getElementGM(j).getListeMat().size();k+
+)
{
{
tgroupe[i].SetGroupeGmSuppMat(j,k);
somme=somme+1;
}
}
}
}
}
cout<<somme<<" suppression ont ete
effectuees";SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
void AjoutGmALL(vector <Groupe> &tgroupe )

{
cout<<"donner l id de groupe dans lequel vous voulez ajouter le gm"<<endl;
string idg;
cin>>idg;
if (x==-1)
cout<<"groupe n existe
}
else
{
GroupeModule y=saisiGM();
if((trouveGM(tgroupe[x].getListeGM(),y.getIdGm())==-
1)&&(VerifGMdansTouTlesGroupes(tgroupe,tgroupe[x].getidgroupe() ,y)==-1))
{
tgroupe[x].SetlistAjoutgm(y);
}
else
cout<<"ce groupe module existe
deja"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
}
}
void MAJgroupeAjoutGM(vector <Groupe> &tgroupe )

{
cout<<"donner l id de groupe qui va etre mis a jour"<<endl;
string idg;
cin>>idg;
if (x==-1)
}
else
{
{
tgroupe[x].SetlistAjoutgm(y);
}
else
}
}
}
void MAJgroupeSppGM(vector<Groupe> &tgroupe)

{ cout<<"donner l id de groupe qui va etre mis a jour"<<endl;
string idg;
cin>>idg;
if (x==-1)
}
else
{
string idgm;
cout<<"donner id du gm que vous souhaitez supprimer"<<endl;
cin>>idgm;
int y=trouveGM(tgroupe[x].getListeGM(),idgm);
if(y==-1)
cout<<"ce groupe module n'existe pas"<<endl;
}
else
{
tgroupe[x].SetlistSuppgm(y);
}
}
}
void AjouterNote(vector <note> &tnote)//////////////////////////////DONE

{
note n=saisiNote();
FILE *t;
t=fopen("archiveNote.txt","a");
fprintf(t,"%d %s %f %s \
n",n.getetudiant().getid(),n.getmatiere().getidmat(),n.getnote(),n.getType());
fclose(t);
tnote.push_back(n);
}
int trouvenote(vector <note> tnote,note n)

{
int trouv=-1;
int i=0;
while ((trouv=-1)&&(i<tnote.size()))
{
if
((tnote[i].getetudiant().getid()==n.getetudiant().getid())&&(tnote[i].getmatiere().
getidmat()==n.getmatiere().getidmat())&&(tnote[i].getType()==n.getType())&&(tnote[i
].getnote()==n.getnote()))
{
trouv=i;
return trouv;
}
i++;
}
return trouv;
}
void SUPPNote(vector <note> &tnote)

{
note n=saisiNote();
int x=trouvenote(tnote,n);
if(x==-1)
cout<<"cette note n'existe
}
else
{
vector <note>::iterator it;
it=tnote.begin();
tnote.erase(it+x);
}
void AjouterEtudiantALL(vector <Groupe> &tgroupe)

{
Etudiant e=saisiEtudiant();
int x=e.getid();
int z=e.getNumInscc();
int verif=-1;
int i=0;
while ((verif==-1)&&(i<tgroupe.size()))
{
if ((trouveEtu(tgroupe[i].getListeEtudiants(), x)!=-1)||
(trouveNumInsc(tgroupe[i].getListeEtudiants(), z)!=-1))
{
verif=0;
}
i++;
}
if(verif==0) {SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"cet Etudiant existe
deja"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else
{ string idg;
cout<<"Dans quel Groupe vous voulez ajouter cet Etudiant"<<endl;
cin>>idg;
int y=trouve(tgroupe,idg);
if (y==-1) {SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"Ce Groupe n'existe
pas"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else {
tgroupe[y].AjoutEtu(e);
}
}
void MAJGroupeAjouterEtudiant(vector <Groupe> &tgroupe)

{
Etudiant e=saisiEtudiant();
int x=e.getid();
int z=e.getNumInscc();
int verif=-1;
int i=0;
{
if ((trouveEtu(tgroupe[i].getListeEtudiants(), x)!=-1)||
(trouveNumInsc(tgroupe[i].getListeEtudiants(), z)!=-1))
{
verif=0;
}
i++;
}
if(verif==0) {cout<<"cet Etudiant existedeja"<<endl;}

else
{ string idg;
cout<<"Donner l id du groupe a mette a jour"<<endl;
cin>>idg;
int y=trouve(tgroupe,idg);
if (y==-1) {SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"Ce Groupe n'existe
pas"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else {
tgroupe[y].AjoutEtu(e);}
}
void SUPPetudiantALL(vector <Groupe> &tgroupe)

{ int idetu;
cout<<"donner l id de l etudiant que vous souhaitez supprimer"<<endl;
cin>>idetu;
int verif=-1;
int i=0;
int x=trouveEtu(tgroupe[i].getListeEtudiants(), idetu);
{
if (x!=-1)
{
verif=0;
}
i++;
}
if(verif==-1) {SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"cet Etudiant n'existe pas
"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else
{
tgroupe[x].SuppEtu(idetu);
}
void AjouterGmALL(vector <Groupe> &tgroupe)

{
string idg;
cout<<"Donner l id du groupe dans lequel vous souhaitez ajouter le GM"<<endl;
cin>>idg;
if (x==-1){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"Ce Groupe n'existe pas
";SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else
{
{
tgroupe[x].getListeGM().push_back(y);
}
else
void SuppGmALL(vector <Groupe> &tgroupe)

{
string idgm;
cout<<"Donner l id du groupe module que vous souhaitez supprimer"<<endl;
cin>>idgm;
int supp=0;
int i;
{ int j;
for(j=0;j<tgroupe[i].getListeGM ().size();j++)
{
if(tgroupe[i].getElementGM(j).getIdGm()==idgm)
tgroupe[i].SetlistSuppgm(j);
supp=supp+1;
}
}
}
cout<<supp<<" suppression ont ete effectuee"<<endl;
}
int VerifGMatiere(vector <GroupeModule> tgm,string idm)
{
int trouv=-1;
int i=0;
while((trouv==-1)&&(i<tgm.size()))
{ int j=0;
while((trouv==-1)&&(j<tgm[i].getListeMat().size()))
{
if(tgm[i].getElemntMat(j).getidmat()==idm)
{
trouv=0;
return trouv;
}
j++;
}
i++;
}
return trouv;
}
void MajGroupeAjouterMatiereGm(vector <Groupe> &tgroupe)

{
string idg;
cout<<"Donner l id du groupe dans lequel vous souhaitez ajouter le GM"<<endl;
cin>>idg;
string idgm;
cout<<"Donner l id du groupe module dans lequel vous souhaitez ajouter le
GM"<<endl;
cin>>idgm;
if (x==-1){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"Ce Groupe n'existe pas
";SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else
{ Matiere y=saisiMatiere();
int z=trouveGM(tgroupe[x].getListeGM(),idgm);
if(z!=-1)
{
if(VerifGMatiere(tgroupe[x].getListeGM(), y.getidmat())==-1)
{
tgroupe[x].SetGroupeGmAjoutMatiere(z,y);
}
else
cout<<"cette matiere existe
}
}
else
cout<<"ce groupe module n'existe
}
}
}
void SuppMatiereALL(vector <Groupe> &tgroupe)

{ string idm;
cout<<"donner l id de la matiere que vous voulez supprimer"<<endl;
cin>>idm;
int somme=0;
{
{
{
{
tgroupe[i].setGroupeGmSuppMat(j,k);
somme=1;
}
}
}
}
if (somme==0)
cout<<"aucune suppression n a ete
effectuee"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
else
cout<<somme<<" suppression ont ete
effectuees"<<endl;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
void SuppMatGrp(vector <Groupe> &tgroupe)

{ string idg;
cout<<"donner l id du groupe pour supprimer sa matiere"<<endl;
if(x==-1){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x04);
cout<<"ce groupe n existe
pas"<<endl ;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else
{ int somme=0;
string idm;
cout<<"donner l id de matiere que vous voulez supprimer"<<endl;
cin>>idm;
for(int i=0;i<tgroupe[x].getListeGM().size();i++)
{
for(int j=0;j<tgroupe[x].getElementGM(i).getListeMat().size();j++)
{
if(tgroupe[x].getElementGM(i).getElemntMat(j).getidmat()==idm)
{
tgroupe[x].setGroupeGmSuppMat(i,j);
somme=1;
}
}
}
cout<<somme<<" supression a ete effectuee"<<endl;
}
void affichePV(vector<Groupe> tgroupe, vector<note> tnote)

{
cout << "Donner l'identifiant du groupe : " << endl;
string idg;
cin >> idg;
int x = trouve(tgroupe, idg);
if (x == -1)
cout << "Ce groupe n'existe pas." << endl;
}
else
{
// Affichage des informations générales du groupe
cout << setw(20) << left << "Nom du groupe : ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F); cout<<
tgroupe[x].getidgroupe() << endl;
cout << setw(20) << left << "Nombre d'etudiants : " <<
tgroupe[x].getListeEtudiants().size() << endl;
cout << endl;
// Affichage des matières du groupe

cout << setw(20) << left << "Grp Modules : " << endl;
for(int z=0;z<tgroupe[x].getListeGM().size();z++)
cout << setw(20) << left << tgroupe[x].getElementGM(z).getNomGm() <<
endl; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
cout << " Coeff : " <<
tgroupe[x].getElementGM(z).getcoef() << endl;
cout << " Matieres : ";
for(int y=0;y<tgroupe[x].getElementGM(z).getListeMat().size();y++)
cout << tgroupe[x].getElementGM(z).getElemntMat(y).getNomMatiere()
<< " "; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}
cout << endl;
cout <<
"---------------------------------------------------------------------" << endl;
cout << " Coeff : ";
{
cout << tgroupe[x].getElementGM(z).getElemntMat(y).getcoef() << "
";
}
cout << endl;
}
cout << endl;
// Affichage des notes de chaque étudiant

cout << setw(10) << left << "ID " << setw(20) << left << "Nom" << setw(20)
<< left << "Prenom"; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x0F);
for(int z=0;z<tgroupe[x].getListeGM().size();z++)
{
cout << setw(10) << left <<
tgroupe[x].getElementGM(z).getElemntMat(y).getNomMatiere();
}
cout << setw(10) << left << tgroupe[x].getElementGM(z).getNomGm() ;
} SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
cout<<"Moyenne ";
cout<<"Resultat ";
cout<<"Mention "<<endl;
for(int i=0;i<tgroupe[x].getListeEtudiants().size();i++)
{
cout << setw(10) << left << tgroupe[x].getElementETU(i).getNumInscc()
<< setw(20) << left
<< tgroupe[x].getElementETU(i).getNomPersonne() << setw(20) <<
left
<< tgroupe[x].getElementETU(i).getPrenomPersonne();
for(int j=0;j<tgroupe[x].getListeGM().size();j++)
{
for(int k=0;k<tgroupe[x].getElementGM(j).getListeMat().size();k++)
{
float a = Moymat(tnote,
tgroupe[x].getElementGM(j).getElemntMat(k).getidmat(),
tgroupe[x].getElementETU(i).getid());
cout << setw(10) << left << a;
}
cout << setw(10) << left << tgroupe[x].getElementGM(j).MoyGM(tnote,
tgroupe[x].getElementETU(i).getid());
}
cout<<setw(12) <<
left<<tgroupe[x].Moyenne(tgroupe[x].getElementETU(i).getid(), tnote);
float y=tgroupe[x].Moyenne(tgroupe[x].getElementETU(i).getid(),
tnote);
cout<< setw(12)<<left<<Resultat(y);
cout<< setw(12) << left <<Mention(y);
cout << endl;

}
}
}
void affichageToutlesGrp(vector <Groupe> tgroupe)

{
{
cout<<tgroupe[i];
}
void affichageToutLesGM(vector <Groupe> tgroupe)

{
cout<<"donner l id du Groupe"<<endl;
string idg; cin>>idg;
cout<<"Ce Groupe n existe
pas";SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);}
else
{
for(int j=0;tgroupe[x].getListeGM().size();j++)
{
cout<<tgroupe[x].getElementGM(j).getNomGm()<<endl;
}
}
}
void affichageToutLesEtu(vector <Groupe> tgroupe)

{
if(x==-1){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
0x04);cout<<"Ce Groupe n existe
else
{
for(int j=0;tgroupe[x].getListeEtudiants().size();j++)
{
cout<<tgroupe[x].getElementETU(j)<<endl;
}
}
}
void affichageToutLesMat(vector <Groupe> tgroupe)
{
cout<<"Ce Groupe n existe
else
{ cout<<"La Liste des Matieres :"<<endl;
for(int j=0;tgroupe[x].getListeGM().size();j++)
{
for(int k=0;tgroupe[x].getElementGM(j).getListeMat().size();k++)
{
cout<<tgroupe[x].getElementGM(j).getElemntMat(k).getNomMatiere()<<"
,";
}
}
}
}
//---------------------------------------------------------------------------------
----------------------
//---------------------------------------------------------------------------------
----------------------
//---------------------------------------------------------------------------------
----------------------
//---------------------------------------------------------------------------------
----------------------
//---------------------------------------------------------------------------------
----------------------
//---------------------------------------------------------------------------------
----------------------
int mainmenu()
{ int c ;
printf(" * Veuillez choisir une option:
*\n");SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
printf(" * 1- Affichage PV
*\n");
printf(" * 2- Moyenne Etudiant
*\n");
printf(" * 3- Faire des Modifications
*\n");
do {
printf(" * >> Tapez votre Choix:
c=0;
}while ( (c!=1)&&(c!=2)&&(c!=0)&&(c!=3));
printf("\n");
scanf("%d",&c);
return c;
int menuGestion()
int c;
printf(" * 1- Gestion des Groupes

*\n");
printf(" * 2- Gestion des Groupes Modules
*\n");
printf(" * 3- Gestion des Etudiants
*\n");
printf(" * 4- Gestion des Matieres
*\n");
printf(" * 5- Gestion des Enseignants
*\n");
printf(" * 6- Gestion des Notes
*\n");
printf(" * 7- Retour Menu Principal
*\n");
do {
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=5)&&(c!=6)&&(c!=7)&&(c!=0));
return c ;
}
int menuGestionGroupe()
int c;
printf(" * 1- Ajouter Groupe

*\n");
printf(" * 2- Supprimer Groupe
*\n");
printf(" * 3- MAJ Groupe
*\n");
*\n");
do {
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&& (c!=4)&&(c!=0));
return c ;
int menuMAJgroupe()
int c;
printf(" * 1 - Modifier Niveau du
Groupe *\n");
printf(" * 2 - Modifier Diplome du
Groupe *\n");
printf(" * 3 - Modifier Specialite du
Groupe *\n");
printf(" * 4 - Modifier Numero du
Groupe *\n");
printf(" * 5 - Ajouter Groupe Module
*\n");
printf(" * 6 - Supprimer Groupe Module
*\n");
printf(" * 7 - Ajouter Etudiant
*\n");
printf(" * 8 - Supprimer Etudiant
*\n");
printf(" * 9 - Ajouter Matiere
*\n");
printf(" * 10- Supprimer Matiere
*\n");
*\n");
do {
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=5)&&(c!=6)&&(c!=7)&&(c!=8)&&(c!
=9)&&(c!=10)&&(c!=11)&&(c!
=0));SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
return c ;
}
int menuGestionGM()
int c;
printf(" * 1- Ajouter Groupe Module

*\n");
printf(" * 2- Supprimer Groupe Module
*\n");
printf(" * 3- MAJ Groupe Module
*\n");
*\n");
do {SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&& (c!=4)&&(c!=0));
return c ;
}
int menuMAJGm()
int c;
printf(" * 1 - Modifier Nom du Groupe
Module *\n");
printf(" * 2 - Modifier Coef du Groupe
Module *\n");
*\n");
printf(" * 4 - Supprimer Matiere
*\n");
printf(" * 5 - Retour Menu Principal
*\n");
do {
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=5)&&(c!=0));
return c ;
int menuGestionEtudiant()
int c;
printf(" * 1- Ajouter Etudiant

*\n");
printf(" * 2- Supprimer Etudiant
*\n");
printf(" * 3- MAJ Etudiant
*\n");
*\n");
do {
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&& (c!=4)&&(c!=0));
return c ;
int menuAFF()
{int c;
printf(" * 1 - Afficher toutes les infos des
Grp *\n");
printf(" * 2 - Afficher tous les GM des
Grp *\n");
printf(" * 3 - Afficher tous les Etu des
Grp *\n");
printf(" * 4 - Afficher toutes les MAT des
Grp *\n");
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=5)&&(c!=0));
return c ;
int menuMAJEtu()
{int c;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
printf(" * 1 - Modifier Nom de
l'Etudiant *\n");
printf(" * 2 - Modifier Mail de
l'Etudiant *\n");
printf(" * 3 - Modifier Prenom de
l'Etudiant *\n");
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=0));
return c ;
}
int menuGestionMatiere()
{
int c;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);

*\n");
printf(" * 2 - Supprimer Matiere
*\n");
printf(" * 3 - MAJ Matiere
*\n");
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&& (c!=4)&&(c!=0));
return c ;
}
int menuMAJMat()
{
Matiere *\n");
printf(" * 2 - Modifie Coef de
Matiere *\n");
printf(" * 3 - Modifier Enseignant de
Matiere *\n");
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=0));
return c ;
}
int menuGestionNote()
{
printf(" * 1- Ajouter Note

*\n");
printf(" * 2- Supprimer Note
*\n");
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&((c!=0)));
return c ;
int menuGestionProf()
{
printf(" * 1- MAJ Enseignant

*\n");
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=2)&&(c!=0));
return c ;
int menuMAJEnseignant()
{
l'Enseignant *\n");
printf(" * 2 - Modifier Mail de
l'Enseignant *\n");
printf(" * 3 - Modifier Prenom de
l'Enseignant *\n");
*\n");
*\n");
scanf("%d",&c);SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0F);
}while ( (c!=1)&&(c!=2)&& (c!=3)&&(c!=4)&&(c!=0));
return c ;
}
int terminer(){
int c ;SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
printf("\n * 1- Retour Menu Principal
*\n");
do {
*\n");
scanf("%d",&c);
}while ( (c!=1)&&(c!=0));
printf("\n");
return c ;
}
void affiche(vector <Groupe> tgroupe)

{
int i;
int j;
int k ;
{
cout<<"groupe "<<tgroupe[i].getDiplome()<<endl;
for(j=0;j<tgroupe[i].getListeGM().size();j++)
{
cout<<"gm "<<tgroupe[i].getElementGM(j).getNomGm()<<endl;
for(k=0;k<tgroupe[i].getElementGM(j).getListeMat().size();k++)
{
cout<<"mat
"<<tgroupe[i].getElementGM(j).getElemntMat(k).getNomMatiere()<<endl;///////////////
//////////////////////////////////////////
cout<<"prof
"<<tgroupe[i].getElementGM(j).getElemntMat(k).getEns().getNomPersonne()<<endl;
}
}
}
}
int main()
{ vector <Groupe> tgroupe;

vector <note> tnote ;
vector <GroupeModule> tgm;
vector <Etudiant>tetu;
vector <Matiere> listmat ;
vector <Matiere> listmat2 ;
Etudiant etu(01,"fourat","bahrini","f@gmail",20063);
tetu.push_back(etu);
Etudiant etu2(03,"lina","gharbi","lina@gmail",20044);
tetu.push_back(etu2);
Enseignant ens(02,"hechmi","abd","hechmi@gmail",30063);
Enseignant ens1(8,"marouen","haouela","marouen@gmail",30063);
Enseignant ens2(8,"Lasaad","Hamrouni","hamrouni@gmail",30063);
Enseignant ens3(8,"Ichrak","mehrez","ichrak@gmail",30063);
Matiere m1("301","proba",1.0,ens);
Matiere m2("401","stat",2.0,ens1);
Matiere m3("601","Algo",3.0,ens2);
Matiere m4("701","Java",4.0,ens3);
listmat.push_back(m1);
listmat.push_back(m2);
listmat2.push_back(m3);
listmat2.push_back(m4);
note n1(m1,etu2,16,"ds");
note n3(m1,etu,12,"ds");
tnote.push_back(n1);tnote.push_back(n3);
GroupeModule gm2("501","info",3,listmat2);
GroupeModule gm1("201","math",1,listmat);
tgm.push_back(gm1);
tgm.push_back(gm2);
Groupe g("101","deuxieme","irm","it",1,tgm,tetu);
tgroupe.push_back(g);
int c=mainmenu();
while (c!=0)
{
if(c==1)
{
affichePV(tgroupe, tnote);c=terminer();
if (c==1){c=mainmenu();}
}
else if (c==2)
{ c=menuAFF();
if (c==1 ) {affichageToutlesGrp(tgroupe);c=terminer();if
(c==1){c=mainmenu();}}
else if(c==2 ) {affichageToutLesGM(tgroupe);c=terminer();if
else if(c==3 ) {affichageToutLesEtu(tgroupe);c=terminer();if
else if(c==4 ) {affichageToutLesMat;c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==5 ) {c=mainmenu();}
}
else if (c==3)
{
c=menuGestion();
if(c==1)
{
c=menuGestionGroupe();
if(c==1)
{
AjouterGroupe(tgroupe);
c=terminer();
}
else if(c==2)
{
SUPPGroupe(tgroupe);affiche(tgroupe);
c=terminer();
}
else if(c==3)
{
c=menuMAJgroupe();
if (c==1 ) {MAJgroupeNiveau(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==2 ) {MAJgroupeDilome(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==3 ) {MAJgroupeSpecialite(tgroupe);c=terminer();if
else if(c==4 ) {MAJgroupeNumG(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==5 ) {MAJgroupeAjoutGM(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==6 ) {MAJgroupeSppGM(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==7 ) {SUPPetudiantALL(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==8 )
{MAJGroupeAjouterEtudiant(tgroupe);c=terminer();if (c==1){c=mainmenu();}}
else if(c==9 )
{MajGroupeAjouterMatiereGm(tgroupe);c=terminer();if (c==1){c=mainmenu();}}
else if(c==10) {SuppMatGrp(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==11) {c=mainmenu();}
}
else if (c==4)
{
c=mainmenu();
}
}
else if(c==2)
{
c=menuGestionGM();
if(c==1)
{
AjouterGmALL(tgroupe);c=terminer();if (c==1){c=mainmenu();}
}
else if(c==2)
{
SuppGmALL(tgroupe);c=terminer();if (c==1){c=mainmenu();}
}
else if(c==3)
{
c=menuMAJGm();
if (c==1 ) {MAJgmNom(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==2 ) {MAJgmCoef(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==3 ) {MajGmAjoutMat(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==4 ) {MajGmSuppMat(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
}
else if (c==4)
{
c=mainmenu();
}
}
else if(c==3)
{
c=menuGestionEtudiant();
if(c==1)
{
AjouterEtudiantALL(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}
}
else if(c==2)
{
SUPPetudiantALL(tgroupe);c=terminer();if (c==1){c=mainmenu();}
}
else if(c==3)
{
c=menuMAJEtu();
if (c==1 ) {MajEtudiantNom(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==2 ) {MajEtudiantPrenom(tgroupe);c=terminer();if
else if(c==3 ) {MajEtudiantMail(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==4 ) {c=mainmenu();c=terminer();if (c==1)
{c=mainmenu();}}
}
else if (c==4)
{
c=mainmenu();
}
}
else if(c==4)
{
c=menuGestionMatiere();
if(c==1)
{
AjoutMatALL(tgroupe);c=terminer();if (c==1){c=mainmenu();}
}
else if(c==2)
{
SuppMatiereALL(tgroupe);c=terminer();if (c==1){c=mainmenu();}
}
else if(c==3)
{
c=menuMAJMat();
if (c==1 ) {MajMatNom(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==2 ) {MajMatCoef(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==3 ) {MajMatiereProf(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
}
else if (c==4)
{
c=mainmenu();
}
}
else if(c==5)
{
c=menuGestionProf();
if(c==1)
{
c=menuMAJEnseignant();
if (c==1 ) {MajProfNom(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==2 ) {MajProfPrenom(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==3 ) {MajProfMail(tgroupe);c=terminer();if (c==1)
{c=mainmenu();}}
else if(c==4 ) {c=mainmenu();c=terminer();if (c==1)
{c=mainmenu();}}
}
else if(c==2)
{
c=mainmenu();
}
}
else if(c==6)
{
c=menuGestionNote();
if(c==1)
{
AjouterNote(tnote);c=terminer();if (c==1){c=mainmenu();}
}
else if (c==2)
{
SUPPNote(tnote);c=terminer();if (c==1){c=mainmenu();}
}
else if (c==3)
{
c=mainmenu();
}
}
}
return 0;
}

C++ v8

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C++ v8

Transféré par

Droits d'auteur :

Formats disponibles

#include <iostream>

ostream& operator<<(ostream& cout ,const Personne& p)

class Etudiant : public Personne {

Etudiant::Etudiant(int id,string nom,string prenom,string mail,int Num_insc):

// surcharge de l op << pour Etudiant

ostream& operator<<(ostream& cout ,const Etudiant& e)

class Enseignant : public Personne {

Enseignant::Enseignant(int id,string nom,string prenom,string mail,int

// surcharge de l op << pour Enseignant

ostream& operator<<(ostream& flux ,const Enseignant& e)

// surcharge de l op << pour matiere

// surcharge de l op << pour note

ostream& operator<<(ostream& cout ,const note& n)

float Moymat(vector <note> tnote,string idmat,int idEtu)

// surcharge de l op << pour groupe module

ostream& operator<<(ostream& cout ,const GroupeModule& gm)

float Moyenne(int idEtu ,vector <note> tnote);

void Groupe::SuppEtu(int idetu)

int trouveNumInsc(vector <Etudiant> ListeEtudiants,int numEtu)

// affichage moyenne etudiant

// constructeur de l'objet Groupe

ostream& operator<<(ostream& cout ,const Groupe& g)

cout<<"Donner le Nom de l'Etudiant"<<endl;

cout<<"Donner le Prenom de l'Etudiant"<<endl;

cout<<"Donner le Mail de l'Etudiant"<<endl;

cout<<"Donner le Numero d'Inscription de l'Etudiant"<<endl;

cout<<"Donner id Enseignant "<<endl;

cout<<"Donner le Nom de l'Enseignant"<<endl;

cout<<"Donner le Prenom de l'Enseignant"<<endl;

cout<<"Donner le Mail de l'Enseignant"<<endl;

cout<<"Donner le Numero d'Inscription de l'Enseignant"<<endl;

cout<<"Donner le Nome de Matiere"<<endl;

cout<<"Donner le Coef de la Matiere"<<endl;

cout<<"donner ID du Groupe Module"<<endl;

cout<<"donner le Nom du Groupe Module"<<endl;

cout<<"donner le Coef du Groupe Module"<<endl;

cout<<"donner le Nombre de Matiere dans ce Groupe Module"<<endl;

int trouve(vector <Groupe> tgroupe,string idg)

int trouveGM(vector <GroupeModule>ListeModules,string idgm)

int trouveEtu(vector <Etudiant> ListeEtudiants,int idetu)

void AjouterGroupe(vector <Groupe> &tgroupe)

void SUPPGroupe(vector <Groupe> &tgroupe)

void MAJgroupeNiveau(vector <Groupe> &tgroupe)

int VerifGMdansTouTlesGroupes(vector <Groupe> tgroupe,string idg ,GroupeModule gm)

int ExisteGM(vector <Groupe> tgroupe,string idgm)

void MajMatNom(vector <Groupe> &tgroupe)

void MajMatCoef(vector <Groupe> &tgroupe)

void MajMatiereProf(vector <Groupe> &tgroupe)

void MajProfNom(vector <Groupe> &tgroupe)///////////////////////DONEEEEEEEEEEEEEE

void MajProfPrenom(vector <Groupe> &tgroupe)///////////////////////:DONEEEEEEEEEE

void MajProfMail(vector <Groupe> &tgroupe)////////////////////////:DONEEEEEEEEEEE

void MajEtudiantNom(vector <Groupe> &tgroupe)

void MajEtudiantPrenom(vector <Groupe>

void MajEtudiantMail(vector <Groupe> &tgroupe)

void MAJgmNom(vector <Groupe> &tgroupe)

void MAJgmCoef(vector <Groupe> &tgroupe)

int VerifGmMatiere(vector <Matiere> listMat, string idm)

void MajGmAjoutMat(vector <Groupe> &tgroupe)

void AjoutMatALL(vector <Groupe> &tgroupe)

void AjoutGmALL(vector <Groupe> &tgroupe )

void MAJgroupeAjoutGM(vector <Groupe> &tgroupe )

void MAJgroupeSppGM(vector<Groupe> &tgroupe)

void AjouterNote(vector <note> &tnote)//////////////////////////////DONE

int trouvenote(vector <note> tnote,note n)