ENIB LANG-CPP Ex_0104 - Levée d'une exception

{1} Première variante

Les déclarations suivantes doivent faire partie de l'espace de noms basics dans le fichier exceptions.hpp :

struct Interval
{
  double low, high;
};

double
range(Interval i);

Il s'agit d'une part de définir, dans le fichier exceptions.cpp, cette fonction range() afin qu'elle renvoie l'étendue de l'intervalle fourni (high-low).
Avant d'effectuer ce calcul, elle devra cependant s'assurer du fait que la borne low n'est pas supérieure à la borne high ; si tel est le cas, il faudra lever une exception.

D'autre part, il faut réaliser, dans le fichier prog_ex0104.cpp, cette fonction :

void
test_Interval_range()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  try
  {
    // ...test incorrect interval...
  }
  catch(const std::exception &e)
  {
    std::cerr << "!!! Exception: " << e.what() << " !!!\n";
  }
  // ...test correct interval...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant à chacun des deux emplacements indiqués une variable de type Interval initialisée avec deux valeurs de votre choix, puis il faudra afficher le résultat de la fonction range() appliquée à chacune de ces variables.
Dans le premier cas les valeurs seront choisies de façon à provoquer une exception, alors que dans le second cas elles ne le devront pas.

{2} Deuxième variante

Les déclarations suivantes doivent faire partie de l'espace de noms basics dans le fichier exceptions.hpp :

struct Fraction
{
  int numer, denom;
};

double
value(Fraction f);

Il s'agit d'une part de définir, dans le fichier exceptions.cpp, cette fonction value() afin qu'elle renvoie la valeur réelle de la fraction fournie (la division de numer par denom, en prenant soin de convertir leurs valeurs vers des réels avant).
Avant d'effectuer ce calcul, elle devra cependant s'assurer du fait que le dénominateur n'est pas nul ; si tel est le cas, il faudra lever une exception.

D'autre part, il faut réaliser, dans le fichier prog_ex0104.cpp, cette fonction :

void
test_Fraction_value()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  try
  {
    // ...test incorrect fraction...
  }
  catch(const std::exception &e)
  {
    std::cerr << "!!! Exception: " << e.what() << " !!!\n";
  }
  // ...test correct fraction...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant à chacun des deux emplacements indiqués une variable de type Fraction initialisée avec deux valeurs de votre choix, puis il faudra afficher le résultat de la fonction value() appliquée à chacune de ces variables.
Dans le premier cas les valeurs seront choisies de façon à provoquer une exception, alors que dans le second cas elles ne le devront pas.

{3} Troisième variante

Les déclarations suivantes doivent faire partie de l'espace de noms basics dans le fichier exceptions.hpp :

struct Duration
{
  int min, sec;
};

int
total_seconds(Duration d);

Il s'agit d'une part de définir, dans le fichier exceptions.cpp, cette fonction total_seconds() afin qu'elle renvoie le nombre total de secondes de la durée fournie (60 fois min plus sec).
Avant d'effectuer ce calcul, elle devra cependant s'assurer du fait que le membre sec n'est pas négatif ni supérieur à 59 ; si tel est le cas, il faudra lever une exception.

D'autre part, il faut réaliser, dans le fichier prog_ex0104.cpp, cette fonction :

void
test_Duration_total_seconds()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  try
  {
    // ...test incorrect duration...
  }
  catch(const std::exception &e)
  {
    std::cerr << "!!! Exception: " << e.what() << " !!!\n";
  }
  // ...test correct duration...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant à chacun des deux emplacements indiqués une variable de type Duration initialisée avec deux valeurs de votre choix, puis il faudra afficher le résultat de la fonction total_seconds() appliquée à chacune de ces variables.
Dans le premier cas les valeurs seront choisies de façon à provoquer une exception, alors que dans le second cas elles ne le devront pas.

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...)
Seule la fonction de test produit des affichages (la fonctionnalité testée rend son service silencieusement) ; un examen attentif des affichages produits doit permettre de vérifier le bon fonctionnement de la fonctionnalité testée.
La facilité ADL doit être utilisée partout où elle s'applique.
L'usage du mécanisme conventionnel pour lever une exception constitue 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 exceptions.hpp✎

Contenu du fichier exceptions.hpp

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

#ifndef BASICS_EXCEPTIONS_HPP
#define BASICS_EXCEPTIONS_HPP

namespace basics {

struct Interval
{
  double low, high;
};

double
range(Interval i);

struct Fraction
{
  int numer, denom;
};

double
value(Fraction f);

struct Duration
{
  int min, sec;
};

int
total_seconds(Duration d);

} // namespace basics

#endif // BASICS_EXCEPTIONS_HPP

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

Fichier exceptions.cpp✎

Contenu du fichier exceptions.cpp

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

#include "exceptions.hpp"

#include <stdexcept>

namespace basics {

double
range(Interval i)
{
  if(i.low>i.high)
  {
    throw std::runtime_error{"incorrect bounds"};
  }
  return i.high-i.low;
}

double
value(Fraction f)
{
  if(f.denom==0)
  {
    throw std::runtime_error{"division by zero"};
  }
  return double(f.numer)/double(f.denom);
}

int
total_seconds(Duration d)
{
  if((d.sec<0)||(d.sec>59))
  {
    throw std::runtime_error{"bad second count"};
  }
  return 60*d.min+d.sec;
}

} // namespace basics

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

Fichier prog_ex0104.cpp✎

Contenu du fichier prog_ex0104.cpp

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

#include "exceptions.hpp"

#include <iostream>
#include <exception>

void
test_Interval_range()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  try
  {
    const basics::Interval i1={5.0, 2.0};
    std::cout << "range of [" << i1.low << "; " << i1.high << "]: "
              << range(i1) << '\n';
  }
  catch(const std::exception &e)
  {
    std::cerr << "!!! Exception: " << e.what() << " !!!\n";
  }
  const basics::Interval i2={2.0, 5.0};
  std::cout << "range of [" << i2.low << "; " << i2.high << "]: "
            << range(i2) << '\n';
}

void
test_Fraction_value()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  try
  {
    const basics::Fraction f1={5, 0};
    std::cout << "value of " << f1.numer << '/' << f1.denom << ": "
              << value(f1) << '\n';
  }
  catch(const std::exception &e)
  {
    std::cerr << "!!! Exception: " << e.what() << " !!!\n";
  }
  const basics::Fraction f2={2, 5};
  std::cout << "value of " << f2.numer << '/' << f2.denom << ": "
            << value(f2) << '\n';
}

void
test_Duration_total_seconds()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  try
  {
    const basics::Duration d1={8, 70};
    std::cout << "seconds in " << d1.min << " m, " << d1.sec << " s: "
              << total_seconds(d1) << '\n';
  }
  catch(const std::exception &e)
  {
    std::cerr << "!!! Exception: " << e.what() << " !!!\n";
  }
  const basics::Duration d2={5, 20};
  std::cout << "seconds in " << d2.min << " m, " << d2.sec << " s: "
            << total_seconds(d2) << '\n';
}

int
main()
{
  test_Interval_range();
  test_Fraction_value();
  test_Duration_total_seconds();
  return 0;
}

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