ENIB LANG-CPP Ex_0301 - Utilisation d'un algorithme sur une séquence

{1} Première variante

Nous nous appuierons sur une structure GenInterval, devant faire partie de l'espace de noms generic dans le fichier find.hpp.
Elle n'est composée que de deux membres low et high dont le type (template) pourra être choisi lors de la création d'une telle structure.

Il faut réaliser, dans le fichier prog_ex0301.cpp, cette fonction :

void
test_GenInterval_find(double value)
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  const std::vector<s4prc::GenInterval<double>> v=
    {{2.3, 3.7}, {5.9, 6.8}, {3.1, 4.6}, {4.2, 5.1}};
  // ...look for an interval in v which contains value...
  // ...if not found, display a message...
  // ...if found, display the interval...
}

qui sera appelée depuis la fonction main() ; elle doit être complétée en suivant les commentaires.
La recherche dans le tableau dynamique v devra utiliser l'algorithme std::find_if().
La lambda-closure qui lui sera transmise indiquera si value est dans l'intervalle considéré : low<=value et high>value.
La recherche de la valeur 1.5 devrait être infructueuse, alors que la recherche de 4.3 devrait trouver l'intervalle 3.1;4.6.

{2} Deuxième variante

Nous nous appuierons sur une structure GenFraction, devant faire partie de l'espace de noms generic dans le fichier find.hpp.
Elle n'est composée que de deux membres numer et denom dont le type (template) pourra être choisi lors de la création d'une telle structure.

Il faut réaliser, dans le fichier prog_ex0301.cpp, cette fonction :

void
test_Fraction_find(s4prc::GenFraction<int> value)
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  const std::vector<s4prc::GenFraction<int>> v=
    {{2, 3}, {3, 5}, {4, 7}, {8, 5}};
  // ...look for a fraction in v which is equivalent to value...
  // ...if not found, display a message...
  // ...if found, display the fraction...
}

qui sera appelée depuis la fonction main() ; elle doit être complétée en suivant les commentaires.
La recherche dans le tableau dynamique v devra utiliser l'algorithme std::find_if().
La lambda-closure qui lui sera transmise indiquera si value est équivalente à la fraction considérée : une fraction a est équivalente à une fraction b si le produit a.numer*b.denom est égal au produit b.numer*a.denom.
La recherche de la valeur {3, 4} devrait être infructueuse, alors que la recherche de {6, 10} devrait trouver la fraction {3, 5}.

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
(#ifndef..., espaces de noms, fichiers d'en-tête, programmation modulaire...)
L'utilisation de l'algorithme std::find_if() et l'exploitation de son résultat constituent l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent.

Code source résultant

Si vous suivez scrupuleusement les énoncés et les consignes, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier find.hpp✎

Contenu du fichier find.hpp

//----------------------------------------------------------------------------

#ifndef GENERIC_FIND_HPP
#define GENERIC_FIND_HPP

namespace generic {

template<typename T>
struct GenInterval
{
  T low, high;
};

template<typename T>
struct GenFraction
{
  T numer, denom;
};

} // namespace generic

#endif // GENERIC_FIND_HPP

//----------------------------------------------------------------------------

Fichier prog_ex0301.cpp✎

Contenu du fichier prog_ex0301.cpp

//----------------------------------------------------------------------------

#include "find.hpp"

#include <iostream>
#include <algorithm>

void
test_GenInterval_find(double value)
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  const std::vector<generic::GenInterval<double>> v=
    {{2.3, 3.7}, {5.9, 6.8}, {3.1, 4.6}, {4.2, 5.1}};
  const auto found=std::find_if(cbegin(v), cend(v),
    [&](const auto &elem)
    {
      return elem.low<=value && elem.high>value;
    });
  if(found==cend(v))
  {
    std::cout << value << " not found\n";
  }
  else
  {
    std::cout << value << " found in "
              << found->low << ';' << found->high << '\n';
  }
}

void
test_GenFraction_find(generic::GenFraction<int> value)
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  const std::vector<generic::GenFraction<int>> v=
    {{2, 3}, {3, 5}, {4, 7}, {8, 5}};
  const auto found=std::find_if(cbegin(v), cend(v),
    [&](const auto &elem)
    {
      return elem.numer*value.denom==value.numer*elem.denom;
    });
  if(found==cend(v))
  {
    std::cout << value.numer << '/' << value.denom << " not found\n";
  }
  else
  {
    std::cout << value.numer << '/' << value.denom << " found as "
              << found->numer << '/' << found->denom << '\n';
  }
}

int
main()
{
  test_GenInterval_find(1.5);
  test_GenInterval_find(4.3);
  test_GenFraction_find({3, 4});
  test_GenFraction_find({6, 10});
  return 0;
}

//----------------------------------------------------------------------------