ООП

#pragma hdrstop
#pragma argsused
#include <conio.h>
#include <stdio.h>
#include <vector>
#include <string>
#include <iostream>
 
using namespace std;
 
class Subject
{
        protected:
                std::string nom;
 
        public:
                Subject()
                {
                        nom=" ";
                }
 
                Subject(std::string _nom)
                {
                        nom=_nom;
                }
 
                Subject(const Subject &m)
                {
                        nom=m.nom;
                }
 
                ~Subject(){};
 
                std::string getNom()
                {
                        return nom;
                }
 
                void setNom(std::string _nom)
                {
                        nom=_nom;
                }
};
 
class Subjectpr: public Subject
{
        public:
                Subjectpr(){};
 
                Subjectpr(std::string nom, int nb_h=0, float t_h=0): Subject(nom)
                {
                        nb_heures=nb_h;
                        tarif_horaire=t_h;
                }
 
                Subjectpr(const Subjectpr &m): Subject(m.nom)
                {
                        nb_heures=m.nb_heures;
                        tarif_horaire=m.tarif_horaire;
                }
 
                int getNombreHeures()
                {
                        return nb_heures;
                }
 
                float getTarifHoraire()
                {
                        return tarif_horaire;
                }
 
                void setNombreHeures(int nb_h)
                {
                        nb_heures=nb_h;
                }
 
                void setTarifHoraire(float t_h)
                {
                        tarif_horaire=t_h;
                }
 
        private:
                int nb_heures;
                float tarif_horaire;
};
 
class Subjectst : public Subject
{       private:
                int note;
 
        public:
                Subjectst()
                {
                        note=10;
                }
 
                Subjectst(std::string _nom, int _note=10): Subject(_nom)
                {
                        note=_note;
                }
 
                Subjectst(const Subjectst &m): Subject(m.nom)
                {
                        note=m.note;
                }
 
                ~Subjectst(){};
 
                int getNote()
                {
                        return note;
                }
 
                void setNote(int _note)
                {
                        note=_note;
                }
};
 
class Personne
{
        protected:
                std::string nom, prenom;
                int age;
 
        public:
                Personne()
                {
                        age=0;
                        if (age<0 && age >>100) {
                        cout<<" erreur , ce n'est pas possible " ;    }
                }
 
                Personne(std::string _nom, std::string _prenom, int _age)
                {
                        nom=_nom; prenom=_prenom; age=_age;
                }
 
                Personne(const Personne &p)
                {
                        nom=p.nom; prenom=p.prenom; age=p.age;
                }
 
                ~Personne(){};
 
                void setNom(std::string _nom)
                {
                        nom=_nom;
                }
 
                void setPrenom(std::string _prenom)
                {
                        prenom=_prenom;
                }
 
                void setAge(int _age)
                {
                        age=_age;
                }
 
                std::string getNom()
                {
                        return nom;
                }
 
                std::string getPrenom()
                {
                        return prenom;
                }
 
                int getAge()
                {
                        return age;
                }
 
                virtual void affiche()
                {
                        std::cout<<"nom: "<<nom<<", prenom: "<<prenom<<", age: "<<age<<std::endl;
                }
 
                Personne & operator= (const Personne &p)
                {
                        nom=p.nom;
                        prenom=p.prenom;
                        age=p.age;
                        return *this;
                }
 
                virtual void ajouterMatiere(Subjectst _m){};
                virtual void ajouterMatiere(Subjectpr m){};
 
};
 
class Student : public Personne
{
        private:
                std::vector<Subjectst> matieres;
 
        public:
                Student(){};
 
                Student(std::string _nom, std::string _prenom, int _age): Personne(_nom, _prenom, _age){};
 
                Student(std::string _nom, std::string _prenom, int _age, const std::vector<Subjectst> &_matieres): Personne(_nom, _prenom, _age)
                {
                        matieres=_matieres;
                }
 
                Student(const Student &et):Personne(et.nom, et.prenom, et.age)
                {
                        matieres=et.matieres;
                }
 
                virtual ~Student(){};
 
                std::vector<Subjectst> getMatieres()
                {
                        return matieres;
                }
 
                double moyenne()
                {
                        if(matieres.size()==0)
                        {
                                return 10;
                        }
                        else
                        {
                                double moy=0;
                                for(int i=0;i<matieres.size();i++)
                                {
                                        moy+= ((double)matieres[i].getNote())/matieres.size();
                                }
                                return moy;
                        }
                }
 
                bool affecterNote(std::string _nom, int _note)
                {
                        int i=0;
                        bool ok=false;
                        while(i<matieres.size() && !ok)
                        {
                                if(matieres[i].getNom()==_nom)
                                {
                                        ok=true;
                                        matieres[i].setNote(_note);
                                }
                                i++;
                        }
                        return ok;
                }
 
                void ajouterMatiere(Subjectst _m)
                {
                        matieres.push_back(_m);
                }
 
                bool supprimerMatiere(std::string _nom)
                {
                        int i=0;
                        bool ok=false;
                        while(i<matieres.size() && !ok)
                        {
                                if(matieres[i].getNom()==_nom)
                                {
                                        ok=true;
                                        i--;
                                }
                                i++;
                        }
                        if(ok)
                        {
                                matieres.erase(matieres.begin()+i);
                        }
                        return ok;
                }
 
                virtual void affiche()
                {
                        Personne::affiche();
                        for(int i=0;i<matieres.size();i++)
                        {
                                std::cout<<"Matiere: "<<matieres[i].getNom()
                                <<", note: "<<matieres[i].getNote()<<std::endl;
                        }
                        std::cout<<"Moyenne: "<<moyenne()<<std::endl;
                }
};
 
class Prof : public Personne
{  public:
                Prof(){};
                Prof(std::string _nom, std::string _prenom, int _age):Personne(_nom, _prenom, _age){};
                Prof(std::string _nom, std::string _prenom, int _age, const std::vector<Subjectpr> &mat): Personne(_nom, _prenom, _age)
                {matieres=mat;
                }
                virtual ~Prof(){};
 
                std::vector<Subjectpr> getMatieres()
                {return matieres;
                }
 
                int getNombreHeuresTotal()
                {       int result=0;
                        for(int i=0;i<matieres.size();i++)
                        {result+=matieres[i].getNombreHeures();
                        }
                        return result;
                }
 
                float cout()
                {       float result=0;
                        for(int i=0;i<matieres.size();i++)
                        {
                                result+=matieres[i].getNombreHeures() * matieres[i].getTarifHoraire();
                        }
                        return result;
                }
 
                void ajouterMatiere(Subjectpr m)
                {matieres.push_back(m);
                }
 
                bool supprimerMatiere(std::string _nom)
                {       int i=0;
                        bool ok=false;
                        while(i<matieres.size() && !ok)
                        {
                                if(matieres[i].getNom()==_nom)
                                {       ok=true;
                                        i--;
                                }
                                i++;
                        }
                        if(ok)
                        {matieres.erase(matieres.begin()+i);
                        }
                        return ok;
                }
 
                virtual void affiche()
                {
                        Personne::affiche();
                        for(int i=0;i<matieres.size();i++)
                        {
                                std::cout<<"Matiere: "<<matieres[i].getNom()
                                <<", nombre d'heures: "<<matieres[i].getNombreHeures()
                                <<", tarif horaire: "<<matieres[i].getTarifHoraire()
                                <<std::endl;
                        }
                        std::cout<<"cout: "<<cout()<<std::endl;
                }
 
        private:
                std::vector<Subjectpr> matieres;
 
};
 
char name;
int main(int argc, char* argv[])
{
        Personne* tableau[2];
        //cout<<"entre Nom , prenom , age" <<endl;
       // cin>> name   ;
        //cout<< name<<"  "<<endl;
        tableau[0]=new Student("Gelsdsad", "Essdfsdssssa", 0);
        tableau[0]->ajouterMatiere(Subjectst("Maths", 13));
        tableau[0]->ajouterMatiere(Subjectst("Conversion d'Energie", 12));
        tableau[0]->ajouterMatiere(Subjectst("Electronique Analogique", 14));
        tableau[0]->affiche();
        tableau[1]=new Prof("Erik Nom_prof", "Prenom_prof", 37);
        tableau[1]->ajouterMatiere(Subjectpr("C", 10, 75.0));
        tableau[1]->ajouterMatiere(Subjectpr("ESD", 10, 75.0));
        tableau[1]->ajouterMatiere(Subjectpr("Analyse Numerique", 8, 80.0));
        tableau[1]->affiche();
 
        delete tableau[0];
        delete tableau[1];
         getch();
        return 0;
}