TD6

Nous souhaitons créer une nouvelle classe d’exception qui dérive de la classe exception et qui compte le nombre de fois qu’une exception est capturée. Nous proposons que cette exception extended_exception dérive de la classe de base std::exception et fournisse en complément des méthodes offertes par la classe de base les méthodes suivantes :

#include<exception>
...
 
class extended_exception : public std::runtime_error
{
  public:
    void catched();
      // Est appelé chaque fois que l’on souhaite indiqué à la classe qu’elle a été
      // capturée. 
   int getCatchNumber() const;
      // Retourne le nombre de fois que l’exception a été capturée.
};

Proposer une implantation de cette classe.

#include<exception>
...
 
class extended_exception: public std::runtime_error
{
private:
    private unsigned m_catched = 0;    
public:
    void catched() { m_catched ++; }
      // Est appelé chaque fois que l’on souhaite indiqué à la classe qu’elle a été
      // capturée. 
   int getCatchNumber() const { return m_catched; }
      // Retourne le nombre de fois que l’exception a été capturée.
};

  explicit extended_exception(const std::string& aMessage): 
      runtime_error(aMessage)
  {}
  explicit extended_exception(const char* aMessage): 
      runtime_error(aMessage)
  {}

Nous proposons de créer une classe exception extended_divide_by_zero qui se comporte comme la classe divide_by_zero mais qui dérive de la classe extended_exception.

Réaliser une implantation de la classe extended_divide_by_zero.

class extended_divide_by_zero: public extended_exception
{
public: 
    division_by_zero(): extended_exception("Division by zero")
    {}
};

Nous proposons de modifier la fonction divide pour qu’elle lance non plus une exception divide_by_zero mais extended_divide_by_zero.

Nous souhaitons tester cette nouvelle fonction avec le code suivant :

double successive_division(double i);
 
 
void test_succesive_division()noexcept
{
  double i;
  std::cout << "Le numerateur: ";
  std::cin >> i;
  try {
   successive_division(i);
  }
  catch(division_by_zero e) { 
    e.catched() ; 
    std::cout << "Division par zero au niveau " << e.getCount() 
               << std::endl ; 
  }
}
 
double successive_division(double i) throw extended_divide_by_zero
{
  double j;
  std::cout << " Le denominateur suivant (-1 pour arreter): ";
  std::cin >> j;
  if(j==-1)
    return i;
  try {
    successive_division(j);
    return divide(i,j);
  }
  catch(extended_divide_by_zero e) {
    e.catched() ; 
    throw e; 
  }
}

Commentez le résultat de l’exécution.