| Exercice 1 | Exercice 2 | Exercice 3 |
La classe Animal ne présente aucune difficulté :
class Animal { public: void affiche() const; protected: string nom; string continent; }; void Animal::affiche() const { cout<<"Je suis un " << nom << " et je vis en " << continent << endl; }
pas plus que les deux autres classes :
class EnDanger { public: void affiche() const; protected: unsigned int nombre; }; void EnDanger::affiche() const { cout << "Il ne reste que " << nombre << " individus de mon espèce sur Terre" << endl; } class Gadget { public: void affiche() const; void affiche_prix() const; protected: string nom; double prix; }; void Gadget::affiche() const { cout << "Mon nom est " << nom << endl; } void Gadget::affiche_prix() const { cout << "Achetez-moi pour " << prix << " francs et vous contribuerez à me sauver!" << endl; }
L'ajout des constructeurs et destructeurs se fait aussi trivialement :
public: Animal(string, string); ~Animal(); void affiche() const; protected: string nom; string continent; }; // ---------------------------------------------------------------------- void Animal::affiche() const { cout << "Je suis un " << nom << " et je vis en " << continent << endl; } // ---------------------------------------------------------------------- Animal::Animal(string nom, string continent) : nom(nom), continent(continent) { cout << "Nouvel animal protégé" << endl; } // ---------------------------------------------------------------------- Animal::~Animal() { cout << "Je ne suis plus protégé" << endl; } // ********************************************************************** class EnDanger { public: void affiche() const; EnDanger(unsigned int); ~EnDanger(); protected: unsigned int nombre; }; // ---------------------------------------------------------------------- EnDanger::EnDanger(unsigned int nombre) : nombre(nombre) { cout << "Nouvel animal en danger" << endl; } // ---------------------------------------------------------------------- EnDanger::~EnDanger() { cout << "ouf! je ne suis plus en danger" << endl; } // ---------------------------------------------------------------------- void EnDanger::affiche() const { cout << "Il ne reste que " << nombre << " individus de mon espèce sur Terre" << endl; } // ********************************************************************** class Gadget { public: void affiche() const; void affiche_prix() const; Gadget(string, double); ~Gadget(); protected: string nom; double prix; }; // ---------------------------------------------------------------------- Gadget::Gadget(string nom, double prix) : nom(nom), prix(prix) { cout << "Nouveau gadget" << endl; } // ---------------------------------------------------------------------- Gadget::~Gadget() { cout << "Je ne suis plus un gadget" << endl; } // ---------------------------------------------------------------------- void Gadget::affiche() const { cout << "Mon nom est " << nom << endl; } // ---------------------------------------------------------------------- void Gadget::affiche_prix() const { cout << "Achetez-moi pour " << prix << " francs et vous contribuerez à me sauver !" << endl; }
Définissez une classe Peluche héritant
des classes Animal, EnDanger
et Gadget :
class Peluche : public Animal, public EnDanger, public Gadget { };
Dotez votre classe Peluche d'une méthode
etiquette [...]
être codée au
moyen des méthodes affiche et
affiche_prix des super-classes. :
class Peluche : public Animal, public EnDanger, public Gadget { public: void etiquette() const; }; void Peluche::etiquette() const { cout << "Hello," << endl; Gadget::affiche(); Animal::affiche(); EnDanger::affiche(); affiche_prix(); cout<<endl; }
puis les constructeurs et destructeurs :
class Peluche : public Animal, public EnDanger, public Gadget { public: void etiquette() const; Peluche(string, string, string, unsigned int, double); ~Peluche(); }; ... Peluche::Peluche(string nom_animal, string nom_gadget, string continent, unsigned int nombre, double prix) : Animal(nom_animal, continent), EnDanger(nombre), Gadget(nom_gadget, prix) { cout << "Nouvelle peluche" << endl; } Peluche::~Peluche() { cout << "Je ne suis plus une peluche" << endl; }
Testez votre programme au moyen du main suivant [...]
Le résultat obtenu est le suivant (ici le code complet) :
#include<iostream> #include<string> using namespace std; // ********************************************************************** class Animal { public: Animal(string, string); ~Animal(); void affiche() const; protected: string nom; string continent; }; // ---------------------------------------------------------------------- void Animal::affiche() const { cout << "Je suis un " << nom << " et je vis en " << continent << endl; } // ---------------------------------------------------------------------- Animal::Animal(string nom, string continent) : nom(nom), continent(continent) { cout << "Nouvel animal protégé" << endl; } // ---------------------------------------------------------------------- Animal::~Animal() { cout << "Je ne suis plus protégé" << endl; } // ********************************************************************** class EnDanger { public: void affiche() const; EnDanger(unsigned int); ~EnDanger(); protected: unsigned int nombre; }; // ---------------------------------------------------------------------- EnDanger::EnDanger(unsigned int nombre) : nombre(nombre) { cout << "Nouvel animal en danger" << endl; } // ---------------------------------------------------------------------- EnDanger::~EnDanger() { cout << "ouf! je ne suis plus en danger" << endl; } // ---------------------------------------------------------------------- void EnDanger::affiche() const { cout << "Il ne reste que " << nombre << " individus de mon espèce sur Terre" << endl; } // ********************************************************************** class Gadget { public: void affiche() const; void affiche_prix() const; Gadget(string, double); ~Gadget(); protected: string nom; double prix; }; // ---------------------------------------------------------------------- Gadget::Gadget(string nom, double prix) : nom(nom), prix(prix) { cout << "Nouveau gadget" << endl; } // ---------------------------------------------------------------------- Gadget::~Gadget() { cout << "Je ne suis plus un gadget" << endl; } // ---------------------------------------------------------------------- void Gadget::affiche() const { cout << "Mon nom est " << nom << endl; } // ---------------------------------------------------------------------- void Gadget::affiche_prix() const { cout << "Achetez-moi pour " << prix << " francs et vous contribuerez à me sauver !" << endl; } // ********************************************************************** class Peluche : public Animal, public EnDanger, public Gadget { public: void etiquette() const; Peluche(string, string, string, unsigned int, double); ~Peluche(); }; // ---------------------------------------------------------------------- Peluche::Peluche(string nom_animal, string nom_gadget, string continent, unsigned int nombre, double prix) : Animal(nom_animal, continent), EnDanger(nombre), Gadget(nom_gadget, prix) { cout << "Nouvelle peluche" << endl; } // ---------------------------------------------------------------------- Peluche::~Peluche() { cout << "Je ne suis plus une peluche" << endl; } // ---------------------------------------------------------------------- void Peluche::etiquette() const { cout << "Hello," << endl; Gadget::affiche(); Animal::affiche(); EnDanger::affiche(); affiche_prix(); cout << endl; } // ********************************************************************** int main() { Peluche panda ("Panda", "Ming", "Asie", 200, 20.0); Peluche serpent("Cobra", "ssss", "Asie", 500, 10.0); Peluche toucan ("Toucan", "Bello", "Amérique du Sud", 1000, 15.0); panda.etiquette(); serpent.etiquette(); toucan.etiquette(); return 0; }
Codez une classe abstraite Employe [...]
class Employe { public: virtual double calculer_salaire() const = 0; protected: string prenom; string nom; unsigned int age; string date; };
Dotez également votre classe d'un constructeur [...] et d'un destructeur virtuel vide.
class Employe { public: Employe(string prenom, string nom, unsigned int age, string date) : nom(nom), prenom(prenom), age(age), date(date) {} virtual ~Employe() {} virtual double calculer_salaire() const = 0; protected: string prenom; string nom; unsigned int age; string date; };
Codez une hiérarchie de classes pour les employés en respectant les conditions suivantes [...]
La première constatation que l'on peut faire c'est que les deux commerciaux (vendeur et représentant) ont une base commune de calcul. On peut créer une sur-classe commune à ces deux classes.
Appelons la par exemple Commercial. Elle reste
bien entendu un classe virtuelle et il n'y a donc qu'à lui affecter
l'attribut nécessaire (chiffre_affaire) et bien
sûr le constructeur qui va avec.
class Commercial: public Employe { public: Commercial(string prenom, string nom, unsigned int age, string date, double chiffre_affaire) : Employe(prenom, nom, age, date), chiffre_affaire(chiffre_affaire) {} ~Commercial() {} protected: double chiffre_affaire; };
On peut alors écrire les deux classes qui en hérite : la
classe Vendeur et la classe Representant :
class Vendeur: public Commercial { public: Vendeur(string prenom, string nom, unsigned int age, string date, double chiffre_affaire) : Commercial(prenom, nom, age, date, chiffre_affaire) {} ~Vendeur() {} double calculer_salaire() const; string get_nom() const; }; class Representant: public Commercial { public: Representant(string prenom, string nom, unsigned int age, string date, double chiffre_affaire) : Commercial(prenom, nom, age, date, chiffre_affaire) {} ~Representant() {} double calculer_salaire() const; string get_nom() const; };
Il n'y a plus qu'ensuite à spécifier leur méthodes spécifiques :
double Vendeur::calculer_salaire() const { return (0.2 * chiffre_affaire) + 400; } string Vendeur::get_nom() const { return "Le vendeur " + prenom + ' ' + nom; } double Representant::calculer_salaire() const { return (0.2 * chiffre_affaire) + 800; } string Representant::get_nom() const { return "Le représentant " + prenom + ' ' + nom; }
[NOTE : pour les programmeurs plus avancés, il serait
mieux de ne pas coder les constantes 400 et
800 «en dur», mais de définir une constante statique à la
classe.
Pour un programme aussi petit et délimité cela ne change pas grand
chose, mais pour un projet d'envergure, cela a son importance :
ne pas mettre de constante en dur dans le code car c'est plus
difficile à maintenir (on risque de ne plus savoir où on les a mises ni
pourquoi elles ont telle ou telle valeur).
]
Les classes Technicien et Manutentionnaire se font de la même façon, sans
difficulté :
class Technicien: public Employe { public: Technicien(string prenom, string nom, unsigned int age, string date, unsigned int unites) : Employe(prenom, nom, age, date), unites(unites) {} ~Technicien() {} double calculer_salaire() const; string get_nom() const; protected: unsigned int unites; }; double Technicien::calculer_salaire() const { return 5.0 * unites; } string Technicien::get_nom() const { return "Le technicien " + prenom + ' ' + nom; } class Manutentionnaire: public Employe { public: Manutentionnaire(string prenom, string nom, unsigned int age, string date, unsigned int heures) : Employe(prenom, nom, age, date), heures(heures) {} ~Manutentionnaire() {} double calculer_salaire() const; string get_nom() const; protected: unsigned int heures; }; double Manutentionnaire::calculer_salaire() const { return 65.0 * heures; } string Manutentionnaire::get_nom() const { return "Le manut. " + prenom + ' ' + nom; }
Voici finalement l'héritage multiple. Mais avant il faut juste définir la super-classe d'employé à risque :
class ARisque { public: ARisque(double prime = 100) : prime(prime) {} virtual ~ARisque() {} protected: double prime; };
Nous avons donc ensuite nos deux classes d'employés à risque. Concernant l'ordre d'héritage, il semble ici évident qu'ils sont avant tous des employés (avant d'être « à risque »).
On a donc naturellement :
class TechnARisque: public Technicien, public ARisque { }; class ManutARisque: public Manutentionnaire, public ARisque { };
qu'il suffit ensuite de nourrir des éléments habituels :
class TechnARisque: public Technicien, public ARisque { public: TechnARisque(string prenom, string nom, unsigned int age, string date, unsigned int unites, double prime) : Technicien(prenom, nom, age, date, unites), ARisque(prime) {} double calculer_salaire() const; }; double TechnARisque::calculer_salaire() const { return Technicien::calculer_salaire() + prime; } class ManutARisque: public Manutentionnaire, public ARisque { public: ManutARisque(string prenom, string nom, unsigned int age, string date, unsigned int heures, double prime) : Manutentionnaire(prenom, nom, age, date, heures), ARisque(prime) {} double calculer_salaire() const; }; double ManutARisque::calculer_salaire() const { return Manutentionnaire::calculer_salaire() + prime; }
Il s'agit ici de quelque chose de très similaire à ce que nous
avons fait la semaine dernière.
Voici donc la solution :
class Personnel { public: void ajouter_employe(Employe* newbie) { staff.push_back(newbie); } void licencie(); void afficher_salaires() const; double salaire_moyen() const; protected: vector<Employe*> staff; }; void Personnel::licencie() { for (auto p : staff) delete p; staff.clear(); } double Personnel::salaire_moyen() const { double somme(0.0); for (auto p : staff) { somme += p->calculer_salaire(); } return somme / staff.size(); } void Personnel::afficher_salaires() const { for (auto p : staff) { cout << p->get_nom() << " gagne " << p->calculer_salaire() << " francs." << endl; } }
Voici pour résumer, le diagramme d'héritage (et encapsulation) de cet exercice :
et ici le code source complet :
#include <iostream> #include <string> #include <vector> using namespace std; /* ********************************************************************** * La classe Employe */ class Employe { public: Employe(string prenom, string nom, unsigned int age, string date) : nom(nom), prenom(prenom), age(age), date(date) {} virtual ~Employe() {} virtual double calculer_salaire() const = 0; virtual string get_nom() const; protected: string nom; string prenom; unsigned int age; string date; }; string Employe::get_nom() const { return "L'employé " + prenom + ' ' + nom; } /* ********************************************************************** * La classe Commercial (factorise Vendeur et Représentant) */ class Commercial: public Employe { public: Commercial(string prenom, string nom, unsigned int age, string date, double chiffre_affaire) : Employe(prenom, nom, age, date), chiffre_affaire(chiffre_affaire) {} ~Commercial() {} protected: double chiffre_affaire; }; /* ********************************************************************** * La classe Vendeur */ class Vendeur: public Commercial { public: Vendeur(string prenom, string nom, unsigned int age, string date, double chiffre_affaire) : Commercial(prenom, nom, age, date, chiffre_affaire) {} ~Vendeur() {} double calculer_salaire() const; string get_nom() const; }; double Vendeur::calculer_salaire() const { return (0.2 * chiffre_affaire) + 400; } string Vendeur::get_nom() const { return "Le vendeur " + prenom + ' ' + nom; } /* ********************************************************************** * La classe Représentant */ class Representant: public Commercial { public: Representant(string prenom, string nom, unsigned int age, string date, double chiffre_affaire) : Commercial(prenom, nom, age, date, chiffre_affaire) {} ~Representant() {} double calculer_salaire() const; string get_nom() const; }; double Representant::calculer_salaire() const { return (0.2 * chiffre_affaire) + 800; } string Representant::get_nom() const { return "Le représentant " + prenom + ' ' + nom; } /* ********************************************************************** * La classe Technicien (Production) */ class Technicien: public Employe { public: Technicien(string prenom, string nom, unsigned int age, string date, unsigned int unites) : Employe(prenom, nom, age, date), unites(unites) {} ~Technicien() {} double calculer_salaire() const; string get_nom() const; protected: unsigned int unites; }; double Technicien::calculer_salaire() const { return 5.0 * unites; } string Technicien::get_nom() const { return "Le technicien " + prenom + ' ' + nom; } /* ********************************************************************** * La classe Manutentionnaire */ class Manutentionnaire: public Employe { public: Manutentionnaire(string prenom, string nom, unsigned int age, string date, unsigned int heures) : Employe(prenom, nom, age, date), heures(heures) {} ~Manutentionnaire() {} double calculer_salaire() const; string get_nom() const; protected: unsigned int heures; }; double Manutentionnaire::calculer_salaire() const { return 65.0 * heures; } string Manutentionnaire::get_nom() const { return "Le manut. " + prenom + ' ' + nom; } /* ********************************************************************** * La classe d'employés à risque */ class ARisque { public: ARisque(double prime = 100) : prime(prime) {} virtual ~ARisque() {} protected: double prime; }; /* ********************************************************************** * une première sous-classe d'employé à risque */ class TechnARisque: public Technicien, public ARisque { public: TechnARisque(string prenom, string nom, unsigned int age, string date, unsigned int unites, double prime) : Technicien(prenom, nom, age, date, unites), ARisque(prime) {} double calculer_salaire() const; }; double TechnARisque::calculer_salaire() const { return Technicien::calculer_salaire() + prime; } /* ********************************************************************** * une autre sous-classe d'employé à risque */ class ManutARisque: public Manutentionnaire, public ARisque { public: ManutARisque(string prenom, string nom, unsigned int age, string date, unsigned int heures, double prime) : Manutentionnaire(prenom, nom, age, date, heures), ARisque(prime) {} double calculer_salaire() const; }; double ManutARisque::calculer_salaire() const { return Manutentionnaire::calculer_salaire() + prime; } /* ********************************************************************** * La classe Personnel */ class Personnel { public: void ajouter_employe(Employe* newbie) { staff.push_back(newbie); } void licencie(); void afficher_salaires() const; double salaire_moyen() const; protected: vector<Employe*> staff; }; void Personnel::licencie() { for (unsigned int i(0); i < staff.size(); i++) { delete staff[i]; } staff.clear(); } double Personnel::salaire_moyen() const { double somme(0.0); for (unsigned int i(0); i < staff.size(); i++) { somme += staff[i]->calculer_salaire(); } return somme / staff.size(); } void Personnel::afficher_salaires() const { for (unsigned int i(0); i < staff.size(); i++) { cout << staff[i]->get_nom() << " gagne " << staff[i]->calculer_salaire() << " francs." << endl; } } // ====================================================================== int main () { Personnel p; p.ajouter_employe(new Vendeur("Pierre", "Business", 45, "1995", 30000)); p.ajouter_employe(new Representant("Léon", "Vendtout", 25, "2001", 20000)); p.ajouter_employe(new Technicien("Yves", "Bosseur", 28, "1998", 1000)); p.ajouter_employe(new Manutentionnaire("Jeanne", "Stocketout", 32, "1998", 45)); p.ajouter_employe(new TechnARisque("Jean", "Flippe", 28, "2000", 1000, 200)); p.ajouter_employe(new ManutARisque("Al", "Abordage", 30, "2001", 45, 120)); p.afficher_salaires(); cout << "Le salaire moyen dans l'entreprise est de " << p.salaire_moyen() << " francs." << endl; // libération mémoire p.licencie(); }
#include <iostream> #include <vector> #include <string> using namespace std; class Couleur { public: typedef enum { ROUGE, VERT, BLEU, BLANC, NOIR } Choix; Couleur(Choix c) : valeur(c) {} virtual ~Couleur() {} Choix valeur; void affiche(ostream&, bool feminin = false) const; }; void Couleur::affiche(ostream& out, bool feminin) const { switch (valeur) { case ROUGE: out << "rouge"; break; case VERT: out << "vert"; if (feminin) out << 'e'; break; case BLEU: out << "bleu"; if (feminin) out << 'e'; break; case BLANC: out << "blanc"; if (feminin) out << "he"; break; case NOIR: out << "noir"; if (feminin) out << 'e'; break; } } // ---------------------------------------------------------------------- class Carte { public: Carte(unsigned int cout_ = 0) : cout(cout_) { // std::cout << " une carte de cout " << cout << " : "; } virtual ~Carte(){} virtual void afficher(ostream& out) const { out << "de coût " << cout; } protected: unsigned int cout; }; ostream& operator<<(ostream& out, const Carte& c) { c.afficher(out); return out; } // ---------------------------------------------------------------------- class Terrain : public virtual Carte { public: Terrain(Couleur c) : couleur(c) { std::cout << "Un nouveau terrain." << endl; } virtual ~Terrain() {} void afficher(ostream&) const; protected: Couleur couleur; }; void Terrain::afficher(ostream& out) const { out << "Un terrain "; couleur.affiche(out); out << "." << endl; } // ---------------------------------------------------------------------- class Creature : public virtual Carte { public: Creature(unsigned int cout_, string nom_, unsigned int attaque_, unsigned int defense_) : Carte(cout_), nom(nom_), attaque(attaque_), defense(defense_) { std::cout << "Une nouvelle créature." << endl; } virtual ~Creature() {} void afficher(ostream&) const; protected: string nom; unsigned int attaque; unsigned int defense; }; void Creature::afficher(ostream& out) const { out << "Une créature " << nom << ' ' << attaque << "/" << defense << ' '; Carte::afficher(out); out << endl; } // ---------------------------------------------------------------------- class Sortilege : public virtual Carte { public: Sortilege(unsigned int cout_, string nom_, string desc) : Carte(cout_), nom(nom_), description(desc) { std::cout << "Un sortilège de plus." << endl; } virtual ~Sortilege() {} void afficher(ostream&) const; protected: string nom; string description; }; void Sortilege::afficher(ostream& out) const { out << "Un sortilège " << nom << ' '; Carte::afficher(out); out << endl; } // ---------------------------------------------------------------------- class CreatureTerrain : public Creature, public Terrain { public: CreatureTerrain(unsigned int cout_, string nom_, unsigned int attaque_, unsigned int defense_, Couleur couleur_) : Carte(cout_), Creature(cout_, nom_, attaque_, defense_), Terrain(couleur_) { std::cout << "Houla, une créature/terrain." << endl; } virtual ~CreatureTerrain() {} void afficher(ostream&) const; }; void CreatureTerrain::afficher(ostream& out) const { out << "Une créature/terrain "; couleur.affiche(out, true); out << ' ' << nom << ' ' << attaque << "/" << defense << ' '; Carte::afficher(out); out << endl; } // ---------------------------------------------------------------------- class Jeu : public vector<Carte*> { public: Jeu(){ cout << "On change de main" << endl; } virtual ~Jeu(){} void jette(); friend ostream& operator<<(ostream&, const Jeu&); }; ostream& operator<<(ostream& out, const Jeu& j) { for (unsigned int i(0); i < j.size(); ++i) out << " + " << *(j[i]); return out; } void Jeu::jette() { cout << "Je jette ma main." << endl; while (!empty()) { delete (*this)[size()-1]; pop_back(); } } // ---------------------------------------------------------------------- int main() { Jeu mamain; mamain.push_back(new Terrain(Couleur::BLEU)); mamain.push_back(new Creature(6, "Golem", 4, 6)); mamain.push_back(new Sortilege(1, "Croissance Gigantesque", "La créature ciblée gagne +3/+3 jusqu'à la fin du tour")); mamain.push_back(new CreatureTerrain(2, "Ondine", 1, 1, Couleur::BLEU)); cout << "Là, j'ai en stock :" << endl; cout << mamain; mamain.jette(); return 0; }