420-KHJ-LG – Intégration de techniques nouvelles en informatique industrielle

Oui, je le veux	Non, je n'en veux pas
William Giguère	Ludovik Allen
Jérémy Lefebvre	Jonathan Caron
Ludovick Martin	Vincent Filion
Yaya Sanogo	Francis Lacasse
	Stéphane Jr. Moreau
	Éric Payment

#include <ostream>
#include <istream>
#include <string>
#include <string_view>
#include <algorithm>
#include <memory>
#include <vector>

using namespace std;

template <class T, class U>
   constexpr bool est_entre_demi_ouvert(const T &val, const U &seuilmin, const U &seuilmax) {
      return seuilmin <= val && val < seuilmax;
   }
template <class T, class U>
   constexpr bool est_entre_inclusif(const T &val, const U &seuilmin, const U &seuilmax) {
      return seuilmin <= val && val <= seuilmax;
   }

class ContrainteNonRespectee { };

template <class T, class Pred>
   const T& valider_contrainte(Pred pred, const T &val) {
      return !pred(val)? throw ContrainteNonRespectee{} : val;
   }

class Monstre {
   string nom_;
public:
   Monstre(string_view nom) : nom_{ nom } {
   }
   string nom() const {
      return nom_;
   }
   virtual ostream& hurler(ostream&) const = 0;
   virtual void mettre_a_jour(ostream&, istream&) = 0;
   virtual ~Monstre() = default;
   //
   // VOTRE CODE ICI
   //
};

ostream& operator<<(ostream &os, const Monstre &monstre) {
   return monstre.hurler(os);
}

bool operator==(const Monstre &a, const Monstre &b) {
   return a.nom() == b.nom();
}
bool operator!=(const Monstre &a, const Monstre &b) {
   return !(a == b);
}

class Bestiole : public Monstre {
   double agacement_; // [0..1)
public:
   Bestiole(string_view nom, double agacement)
      : Monstre{ nom },
        agacement_{ valider_contrainte([](double val) {
           return est_entre_demi_ouvert(val, 0.0, 1.0);
        }, agacement) }
   {
   }
   friend void RendreMoinsAchalant(Bestiole&);
   friend void RendrePlusAchalant(Bestiole&);
   double agacement() const {
      return agacement_;
   }
   ostream& hurler(ostream &os) const override {
      return os << "Je suis " << nom() << " la bestiole, achalant a " << agacement() * 100 << "%";
   }
   void mettre_a_jour(ostream &out, istream &in) override {
      out << R"(Vos options :
   1) rendre plus achalant
   2) rendre moins achalant
Votre choix: )";
      int choix;
      while(in >> choix && !est_entre_inclusif(choix, 1, 2))
         out << R"(Vos options :
   1) rendre plus achalant
   2) rendre moins achalant
Votre choix: )";
      switch (choix) {
      case 1:
         RendrePlusAchalant(*this);
         break;
      case 2:
         RendreMoinsAchalant(*this);
         break;
      }
   }
   //
   // VOTRE CODE ICI
   //
};

class Bibitte : public Monstre {
   int puanteur_; // [1 .. 100]
   double mechancete_; // [0..1)
public:
   Bibitte(string_view nom, int puanteur, double mechancete)
      : Monstre{ nom },
        puanteur_{ valider_contrainte([](int val) {
           return est_entre_inclusif(val, 1, 100);
        }, puanteur) },
        mechancete_{ valider_contrainte([](double val) {
           return est_entre_demi_ouvert(val, 0.0, 1.0);
        }, mechancete) }
   {
   }
   friend void Laver(Bibitte&);
   friend void Salir(Bibitte&);
   int puanteur() const {
      return puanteur_;
   }
   double mechancete() const {
      return mechancete_;
   }
   ostream& hurler(ostream &os) const override {
      return os << "Je suis " << nom() << " la bibitte; puant a " << puanteur() << "% et mechant a " << mechancete() * 100 << "%";
   }
   void mettre_a_jour(ostream &out, istream &in) override {
      out << R"(Vos options :
   1) laver
   2) salir
Votre choix: )";
      int choix;
      while(in >> choix && !est_entre_inclusif(choix, 1, 2))
         out << R"(Vos options :
   1) laver
   2) salir
Votre choix: )";
      switch (choix) {
      case 1:
         Laver(*this);
         break;
      case 2:
         Salir(*this);
         break;
      }
   }
   //
   // VOTRE CODE ICI
   //
};

void Laver(Bibitte &b) {
   b.puanteur_ = 1;
}
void Salir(Bibitte &b) {
   b.puanteur_ = min(100, b.puanteur_ + 5);
}
void RendreMoinsAchalant(Bestiole &b) {
   b.agacement_ -= b.agacement_ * 0.5;
}
void RendrePlusAchalant(Bestiole &b) {
   b.agacement_ += (1.0 - b.agacement_) * 0.5;
}


template <class T>
   unique_ptr<T> modifier_potentiellement(unique_ptr<T> p, ostream &out, istream &in) {
      //
      // VOTRE CODE ICI
      //
   }

#include <iostream>

int main() {
   /*
   vector<unique_ptr<Monstre>> v {
      make_unique<Bibitte>("Joe", 30, 0.75),
      make_unique<Bestiole>("Fred", 0.23),
      make_unique<Bestiole>("Bill", 0.8),
      make_unique<Bibitte>("Zebda", 66, 0.11),
      make_unique<Bestiole>("Guy", 0.99)
   };
   */
   vector<unique_ptr<Monstre>> v;
   v.emplace_back(unique_ptr<Monstre> { new Bibitte{ "Joe", 30, 0.75 }});
   v.emplace_back(unique_ptr<Monstre> { new Bestiole{ "Fred", 0.23 }});
   v.emplace_back(unique_ptr<Monstre> { new Bestiole{ "Bill", 0.8 }});
   v.emplace_back(unique_ptr<Monstre> { new Bibitte{ "Zebda", 66, 0.11 }});
   v.emplace_back(unique_ptr<Monstre> { new Bestiole{ "Guy", 0.99 }});
   for (auto & p : v) {
      cout << "Avant: " << *p << '\n';
      p = modifier_potentiellement(std::move(p), cout, cin);
      cout << "Apres: " << *p << '\n';
   }
}

Vous aurez remarqué que quelques sections de code manquent, sans doute effacées par une créature immonde ou féroce. Votre mandat est de compléter ce programme pour qu'il redevienne fonctionnel.

N'hésitez pas à poser des questions. Cet exercice est à faire sur une base individuelle.

	Comment accéder à du code .NET à partir d'un client C++ natif
	Introduction aux templates
	Introduction aux foncteurs
	Introduction aux conteneurs et aux itérateurs
	Introduction aux expressions lambda (on écrit souvent λ plutôt que lambda)
	Programmation générique appliquée
	Exemple très simple de client par socket (C++)
	Exemple très simple de serveur par socket (C++)
	Exemple plus complet d'infrastructure de communication client/ serveur par socket (C++)

	Cliquez sur cette cible si vous souhaitez un solutionnaire pour les exercices de révision
	Cliquez sur cette cible pour avoir un solutionnaire aux exercices de base
	Cliquez sur cette cible si vous souhaitez un solutionnaire possible au problème des deux implémentations de mutex pour une même interface
	Cliquez sur cette cible pour avoir un exemple de tite_chaine respectant les consignes
	Cliquez sur cette cible si vous souhaitez un solutionnaire possible au problème du clonage des monstres

420-KHJ-LG – Intégration de techniques nouvelles en informatique industrielle

Pratiques de correction

Détail des séances en classe

Programmation générique avec C#

Expressions λ

Parcourir une collection générique avec C#

Votre mandat

Petits coups de pouces

Solutionnaires

	Cliquez sur cette cible pour le plan de cours, sous forme électronique
	Exercices de révision : cliquez sur cette cible pour quelques exercices de révision

	Je corrige les programmes en appliquant des codes de correction. Vous trouverez ici la liste des codes les plus fréquents
	Ma stratégie de correction en tant que telle (pour le code, à tout le moins) est résumée ici