Avant derniere question

src/histogramme.hpp

@@ -8,6 +8,7 @@
 #include <set>
 #include <functional>
 #include <iostream>
+#include <map>
 
 /* class Histogramme {
     double _inf;
@@ -30,6 +31,7 @@ class Histogramme
     double _sup;
     double _step;
     std::set<Classe, COMP> set;
+    std::multimap<Classe, Valeur> map;
 
 public:
     template <typename> friend class Histogramme;
@@ -37,8 +39,10 @@ public:
     Histogramme(double, double, int);
     template <typename T2>
     Histogramme(Histogramme<T2> const & h2);
-    std::set<Classe, COMP> &getClasses();
+    const std::set<Classe, COMP> &getClasses() const;
     void ajouter(double);
+    const std::multimap<Classe, Valeur> & getValeurs() const;
+    auto getValeurs(const Classe&) const;
 };
 
 template <typename COMP>
@@ -59,7 +63,7 @@ Histogramme<COMP>::Histogramme(Histogramme<T2> const & h2) : _inf(h2._inf), _sup
 }
 
 template <typename COMP>
-std::set<Classe, COMP> &Histogramme<COMP>::getClasses()
+const std::set<Classe, COMP> &Histogramme<COMP>::getClasses() const
 {
     return set;
 }
@@ -85,6 +89,33 @@ void Histogramme<COMP>::ajouter(double d)
     c.ajouter();
     set.erase(it);
     set.insert(c);
+    map.insert(std::pair<Classe, Valeur>(c,Valeur(d)));
 }
 
+template <typename COMP>
+const std::multimap<Classe, Valeur> & Histogramme<COMP>::getValeurs() const {
+    return map;
+}
+
+template <typename COMP>
+auto Histogramme<COMP>::getValeurs(const Classe & c) const {
+    return std::equal_range(map.begin(), map.end(), c);
+}
+
+bool operator<(const std::pair<Classe, Valeur> & p1, const Classe& c) {
+    return p1.first.getBorneInf() < c.getBorneInf();
+}
+
+bool operator<(const Classe& c, const std::pair<Classe, Valeur> & p1) {
+    return p1.first.getBorneInf() > c.getBorneInf();
+}
+
+/* bool operator==(const std::pair<Classe, Valeur> & p1, const Classe& c) {
+    return p1.first.getBorneInf() == Approx(c.getBorneInf());
+}
+
+bool operator==(const Classe& c, const std::pair<Classe, Valeur> & p1) {
+    return p1.first.getBorneInf() == Approx(c.getBorneInf());
+} */
+
 #endif
\ No newline at end of file

src/valeur.cpp

 #include "valeur.hpp"
 
-Valeur::Valeur(double nombre) : _nombre(nombre) {}
+Valeur::Valeur(double nombre, std::string nom) : _nombre(nombre), etudiant(nom) {}
 
 const double Valeur::getNombre() const {
     return _nombre;
@@ -9,3 +9,19 @@ const double Valeur::getNombre() const {
 void Valeur::setNombre(double nombre) {
     _nombre = nombre;
 }
+
+double Valeur::getNote() const {
+    return _nombre;
+}
+
+const std::string & Valeur::getEtudiant() const {
+    return etudiant;
+}
+
+void Valeur::setNote(double note) {
+    _nombre = note;
+}
+
+void Valeur::setEtudiant(const std::string & e) {
+    etudiant = e;
+}
\ No newline at end of file

src/valeur.hpp

 #ifndef VALEUR
 #define VALEUR
 
+#include <string>
+
 class Valeur {
     double _nombre;
+    std::string etudiant;
 
     public:
-        Valeur(double=0.0);
+        Valeur(double=0.0, std::string="inconnu");
         const double getNombre() const;
         void setNombre(double);
+        double getNote() const;
+        const std::string& getEtudiant() const;
+        void setNote(double);
+        void setEtudiant(const std::string &);
 };
 
 #endif
\ No newline at end of file

test/tp5_test.cpp

@@ -306,7 +306,7 @@ TEST_CASE ( "TP3_Histogramme::Conversion" ) {
 }
 
 //----------------------------------------------------------------------------------------------- 18
-/*TEST_CASE ( "TP3_Etudiant::Constructeur" ) {
+TEST_CASE ( "TP3_Etudiant::Constructeur" ) {
  const double a = 12.0;
  const char * n = "Machin";
 
@@ -316,19 +316,19 @@ TEST_CASE ( "TP3_Histogramme::Conversion" ) {
  REQUIRE ( v.getNote() == Approx(a) );
  REQUIRE ( v.getEtudiant().c_str() != 0);
  REQUIRE ( v.getEtudiant() == n );
-}*/
+}
 
 //----------------------------------------------------------------------------------------------- 19
-/*TEST_CASE ( "TP3_Etudiant::ConstructeurDefaut" ) {
+TEST_CASE ( "TP3_Etudiant::ConstructeurDefaut" ) {
  Valeur v;
 
  REQUIRE ( v.getNombre() == Approx(0.0) );
  REQUIRE ( v.getNote() == Approx(0.0) );
  REQUIRE ( v.getEtudiant() == "inconnu" );
-}*/
+}
 
 //----------------------------------------------------------------------------------------------- 20
-/*TEST_CASE ( "TP3_Etudiant::Accesseurs" ) {
+TEST_CASE ( "TP3_Etudiant::Accesseurs" ) {
  const double a = 12.0;
  const char * n = "Machin";
 
@@ -340,19 +340,19 @@ TEST_CASE ( "TP3_Histogramme::Conversion" ) {
  REQUIRE ( v.getNombre() == Approx(a) );
  REQUIRE ( v.getNote() == Approx(a) );
  REQUIRE ( v.getEtudiant() == n );
-}*/
+}
 
 //----------------------------------------------------------------------------------------------- 21
-/*TEST_CASE ( "TP3_Etudiant::AccesseursConstants" ) {
+TEST_CASE ( "TP3_Etudiant::AccesseursConstants" ) {
  const Valeur v;
 
  REQUIRE ( v.getNombre() == Approx(0.0) );
  REQUIRE ( v.getNote() == Approx(0.0) );
  REQUIRE ( v.getEtudiant() == "inconnu" );
-}*/
+}
 
 //----------------------------------------------------------------------------------------------- 22
-/*TEST_CASE ( "TP3_Valeurs::Association" ) {
+TEST_CASE ( "TP3_Valeurs::Association" ) {
  using histo_t = Histogramme<>;
 
  double v[] = { 7.0, 9.0, 8.0, 5.0, 10.0, 14.0, 13.0, 6.0, 5.5, 13.5 };
@@ -376,10 +376,10 @@ TEST_CASE ( "TP3_Histogramme::Conversion" ) {
   REQUIRE ( p.second.getNote() == Approx(notes[i]) );
   ++i;
  }
-}*/
+}
 
 //----------------------------------------------------------------------------------------------- 23
-/*TEST_CASE ( "TP3_Valeurs::Intervalle" ) {
+TEST_CASE ( "TP3_Valeurs::Intervalle" ) {
  using histo_t = Histogramme<>;
 
  double v[] = { 7.0, 9.0, 8.0, 5.0, 10.0, 14.0, 13.0, 6.0, 5.5, 13.5 };
@@ -402,10 +402,8 @@ TEST_CASE ( "TP3_Histogramme::Conversion" ) {
  for (const Classe & c : h.getClasses()) {
   auto interval = h.getValeurs(c);
   int j = 0;
-
   while (interval.first != interval.second) {
    REQUIRE ( (interval.first)->second.getNote() == Approx(notes[i][j]) );
-
    ++(interval.first);
    ++j;
   }
@@ -414,6 +412,6 @@ TEST_CASE ( "TP3_Histogramme::Conversion" ) {
 
   ++i;
  }
-}*/
+}
 
 // Fin //-------------------------------------------------------------------------------------------