M2103-TP3-Exo-1

Créez le projet CException.

Dans les fichiers CException.h et CException.cpp, ajouter dans l’espace de noms nsUtil la classe CException, dérivée de la classe standard exception, possédant deux attributs (données membres) :

  • myLibelle : un texte de type string contenant un diagnostic d’erreur,
  • myCodErr : un entier non signé,

et les méthodes suivantes :

  • un constructeur à deux paramètres (le libellé de l’exception et le code de l’erreur), avec d’éventuelles valeurs par défaut,
  • un destructeur virtuel (vide), nécessaire car la classe mère (exception) est elle-même virtuelle,
  • deux accesseurs permettant de récupérer les valeurs des données membres,
  • une récriture de la fonction virtuelle what(), héritée de la classe mère exception, de profil suivant :
    virtual const char* what() const noexcept;
    

    qui, au moyen de la méthode c_str() de la classe string, renvoie le libellé de l’exception sous la forme d’une NTCTS (dont le type est const char*).

  • la fonction d’affichage (provisoire) diplay(), qui affiche à l’écran le contenu de l’exception, par exemple dans le format suivant :
    Exception : xxxxxxxxxxxxxxxxxxxxxxxxxxxx
    Code      : yyyyy
    

Dans la fonction testException() de l’espace de noms anonyme du fichier testCException.cpp, écrire une boucle terminée par la fin de fichier cin, constituée :

  • de la saisie d’une chaîne de caractères (le libellé de l’exception),
  • de la saisie d’un entier (le code d’erreur associé),
  • de la construction d’une CException,
  • de son affichage.

Compiler et tester.

M2103-TP3-Exo-2

La classe standard string est une classe très riche et indispensable et il est heureux qu’elle existe !

Cependant, on peut lui reprocher l’absence de certaines fonctionnalités, que l’on aimerait bien y trouver.

On se souvient, par exemple, de la mise en majuscules ou en minuscules.

Une première solution est d’écrire des “moulinettes”, fonctions prenant comme paramètre donnée (ou donnée-résultat) la string et la rendant transformée.

C’est ce que nous avons fait précédemment (au premier semestre).

La seconde solution consiste à dériver la classe standard string en une classe CString à laquelle ne sont ajoutées aucun attribut (aucune donnée membre), mais seulement des méthodes (fonctions-membres).

Les seules fonctions qui ne sont pas héritées de la classe mère sont ses constructeurs, son destructeur, ainsi que l’affectation.

En revanche, un constructeur par recopie, un constructeur par défaut, un destructeur et une affectation sont données à la nouvelle classe (comme à chaque nouvelle classe), par le compilateur.

En ce qui concerne le constructeur par recopie, l’affectation et le destructeur, ils ne sont pas notre problème pour le moment.

Leur récriture sera abordée en temps utile.

La classe string possède de nombreux constructeurs ayant chacun leur utilité.

Ne posséder qu’un seul constructeur CString() qui se contente d’appeler le constructeur de sa classe mère, string(), qui lui-même crée une chaîne vide, est un peu frustrant.

C’est pourquoi on dotera la classe CString des mêmes constructeurs que sa classe mère.

Créez le projet CString.

Copier / coller le code suivant :

/**
 *
 * \file     TestCString.cpp
 *
 * \authors  M. Laporte, D. Mathieu
 *
 * \date     05/11/2007
 *
 * \version  V1.0
 *
 * \brief    Test de la classe String, extension de String
 *
 **/

#include <iostream>

#include "CString.h"

using namespace std;
using namespace nsUtil;

namespace
{
    void testString (void)
    {
        cout << "Test des constructeurs\n\n";

        CString s1;
        cout << '"' << s1 << "\"\n";
        cout << s1.append ("s1") << '\n';
        CString s2 ("Coucou");
        cout << (s2 + ' ' + s1) << '\n';
        CString s3 ("Coucou", 4);
        cout << s3 << '\n';
        CString s4 (10, '#');
        cout << s4 << '\n';

        CString s5 ("AbCdEf1234");
        cout << s5 << '\n';
        cout << s5.toupper() << '\n';
        cout << s5 << '\n';
        cout << s5.tolower() << '\n';
        cout << s5 << '\n';

        cout << "\nTest des fonctions\n\n";
        CString STR ("MAJUSCULE");
        CString str ("minuscule");
        CString space ("  \t\t\n\n");

        cout << boolalpha;

        cout << str   << " alpha ? "  << str.isalpha   () << '\n';
        cout << str   << " alnum ? "  << str.isalnum   () << '\n';
        cout << str   << " digit ?  " << str.isdigit   () << '\n';
        cout << str   << " xdigit ? " << str.isxdigit  () << '\n';
        cout << str   << " lower ? "  << str.islower   () << '\n';
        cout << str   << " upper ? "  << str.isupper   () << '\n';
        cout << str   << " space ? "  << str.isspace   () << '\n';
        cout << STR   << " upper ? "  << STR.isupper   () << '\n';
        cout << str   << " lower ? "  << str.islower   () << '\n';
        cout << space << " space ? "  << space.isspace () << '\n';

        cout << noboolalpha;

    } // testString ()

} // namespace

int main (void)
{
    testString();

    return 0;

} // main()

Dans l’espace de noms nsUtil des fichiers CString.h et CString.cpp, dériver publiquement la classe string (afin de garder et de transmettre la visibilité sur les fonctions membres de la classe mère).

Lui ajouter les constructeurs ayant les mêmes profils que les constructeurs suivants de la classe string, et qui se contentent d’appeler ces derniers en leur passant les mêmes paramètres :

string (const char * NTCTS); 
string (const char * NTCTS, size_type size);
string (const string & S, size_type pos = 0, size_type size = npos);
string (size_type size, char c);

Ajouter les fonctions membres tolower() et toupper(), de même identificateurs que les fonctions standard tolower() et toupper() qui s’appliquent aux caractères.

Le paramètre désignant la chaîne à traiter n’a plus lieu d’être puisque les fonctions deviennent des méthodes de la classe CString (fonctions-membres), donc appelées sur un objet donné.

Rappel : l’objet lui-même est désigné par (*this).

Ajoutez les prédicats isalpha(), isdigit(), isalnum(), isxdigit(), islower(), isupper(), isspace(), extensions des mêmes fonctions standard existant pour les caractères.

Si vous les avez faites, ajoutez aussi les fonctions complémentaires qui vous avaient été proposées : leftAlign(), compact(), rightAlign(), expandTab(), justify().

M2103-TP2-Exo-1

Remarque préliminaire : cet exercice ne peut être effectué qu’après l’exercice 4 du TP 1 (constructeurs par défaut et par recopie, destructeur).

Récupérer les fichiers sources de l’exo 4 du TP précédent.

Supprimer les affichages intermédiaires dans les constructeurs et dans le destructeur.

Ajouter les surcharges des deux opérateurs + et -, membres de la classe, qui n’ont pour opérande(s) que des objets Duree.

Si la soustraction est impossible (une Duree est considérée comme invalide), le résultat doit être une durée par défaut (nulle).

Téléchargez le fichier de test TestCDuree.cpp.

M2103-TP2-Exo-1-Corrigé

Duree.h

 
/**
 *
 * \file    Duree.h
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  déclarations de la classe Duree (avec constructeurs et 
 *         destructeur)
 *
 **/
 
 #ifndef __DUREE_H__
 #define __DUREE_H__
 
namespace nsUtil
{
    typedef unsigned long long ULLong_t;

	class Duree
	{
	  private :
		ULLong_t       myDuree;
		short unsigned mySeconds;
		short unsigned myMinutes;
		short unsigned myHours;
		ULLong_t       myDays;

		void normaliser (void);

	  public :
		Duree  (const ULLong_t duree = ULLong_t (0));
		Duree  (const Duree & duree);
		~Duree (void);

		ULLong_t getDuree (void) const;

		void display (void) const;

		void incr (const ULLong_t delta = ULLong_t (0));
		void decr (const ULLong_t delta = ULLong_t (0));
		
		Duree operator + (const Duree & d) const;
		Duree operator - (const Duree & d) const;

	}; // Duree

} // nsUtil

#endif /* __DUREE_H__ */

Duree.cpp

 
/**
 *
 * \file    Duree.cpp
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  définitions de la classe Duree
 *
 **/
#include <iostream>
#include <iomanip>   // setw()
#include "Duree.h"

using namespace nsUtil;
using namespace std;

#define DUREE nsUtil::Duree

DUREE::Duree  (const ULLong_t duree /* = ULLong_t (0) */) 
    : myDuree (duree) 
{ 
	normaliser ();
		
} // Duree()

DUREE::Duree  (const Duree & duree) 
    : myDuree (duree.getDuree ()) 
{ 
	normaliser ();
		
} // Duree()

DUREE::~Duree  (void) { }

void DUREE::normaliser (void)
{
	myDays    =  myDuree / 86400;
	myHours   = (myDuree % 86400) / 3600;
	myMinutes = (myDuree % 3600) / 60;
	mySeconds =  myDuree % 60;
	
} // normaliser()

ULLong_t DUREE::getDuree (void) const { return myDuree; }

void DUREE::display (void) const
{
    cout << '[' 
         << setw (10) << myDays    << ':' 
         << setfill ('0')
         << setw (2)  << myHours   << " heure(s)"
         << setw (2)  << myMinutes << " minute(s)"
         << setw (2)  << mySeconds << " seconde(s)"
         << setfill (' ')
         << ']';
		 
} // display()

void DUREE::incr (const ULLong_t delta /* = ULLong_t (0) */)
{
	myDuree += delta;
	normaliser ();
	
} // incr()

void DUREE::decr (const ULLong_t delta /* = ULLong_t (0) */)
{
	myDuree -= (delta > myDuree) ? myDuree : delta;
	
} // decr()

DUREE DUREE::operator + (const Duree & d) const
{
	return myDuree + d.myDuree;
	
} // operator +()

DUREE DUREE::operator - (const Duree & d) const
{
	return myDuree - (myDuree < d.myDuree ? myDuree : d.myDuree);
	
} // operator -()

#undef DUREE

M2103-TP2-Exo-2

Remarque préliminaire : cet exercice ne peut être effectué qu’après l’exercice 1 de ce même TP (opérateurs arithmétiques : + et -).

Récupérer les fichiers sources de l’exercice précédent.

Téléchargez le fichier
TestDureeRelops.cpp
.

Opérateur >

A la classe Duree, ajouter la surcharge de l’opérateur >.

Compiler le fichier TestCDureeRelops.cpp en mettant en commentaires les instructions contenant des erreurs.

Vous devez remarquer que > reste le seul opérateur accessible.

Opérateur <

Dans la classe Duree :

  1. remplacer l’opérateur > par l’opérateur <,
  2. inclure le fichier standard <utility> dans le fichier TestCDureeRelops.cpp,
  3. ajouter la clause using namespace rel_ops
  4. réactiver toutes les instructions du fichier qui utilisent les opérateurs de comparaison,
  5. recompiler le fichier TestCDureeRelops.cpp et tester.

Vous remarquez alors que le seul ajout de < rend possible l’utilisation des opérateurs <=, >= et >.

Cela est dû au fait que le C++ propose des versions génériques de <=, >= et >, définies à partir de < et qui s’instancient automatiquement en cas de besoin.

Il est donc totalement inutile et en général mauvais de surcharger les trois autres opérateurs.

Il peut être surprenant de ne pas obtenir les opérateurs == et != à partir de <, alors que c’est mathématiquement possible.

Mais c’est normal en informatique …

Opérateur !=

A la classe Duree, ajouter la surcharge de l’opérateur !=.

Compiler le fichier TestCDureeRelops.cxx en mettant en commentaires les instructions contenant des erreurs.

Vous remarquez alors que seule l’inégalité est ajoutée.

Opérateur ==

Remplacez alors la surcharge de != par celle de ==.

Normalement, toutes les instructions de TestCDureeRelops.cpp passent à la compilation.

Le seul ajout de == rend possible l’utilisation de l’opérateur !=.

Nous montrerons dans un qu’elle rend aussi possible l’utilisation de la fonction générique standard find() (et bien d’autres !).

Pour conclure :

  • une classe qui possède la surcharge de l’opérateur < est dite LessThanComparable.Elle possède alors une relation d’ordre.
  • une classe qui possède la surcharge de l’opérateur == est dite EqualityComparable.

M2103-TP2-Exo-2-Corrigé

Duree.h

 
/**
 *
 * \file    Duree.h
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  déclarations de la classe Duree (avec constructeurs et 
 *         destructeur)
 *
 **/
 
 #ifndef __DUREE_H__
 #define __DUREE_H__
 
namespace nsUtil
{
    typedef unsigned long long ULLong_t;

	class Duree
	{
	  private :
		ULLong_t       myDuree;
		short unsigned mySeconds;
		short unsigned myMinutes;
		short unsigned myHours;
		ULLong_t       myDays;

		void normaliser (void);

	  public :
		Duree  (const ULLong_t duree = ULLong_t (0));
		Duree  (const Duree & duree);
		~Duree (void);

		ULLong_t getDuree (void) const;

		void display (void) const;

		void incr (const ULLong_t delta = ULLong_t (0));
		void decr (const ULLong_t delta = ULLong_t (0));
		
		Duree operator +  (const Duree & d) const;
		Duree operator -  (const Duree & d) const;
		
		bool  operator >  (const Duree & d) const;
		bool  operator <  (const Duree & d) const;
		bool  operator != (const Duree & d) const;
		bool  operator == (const Duree & d) const;

	}; // Duree

} // nsUtil

#endif /* __DUREE_H__ */

Duree.cpp

 
/**
 *
 * \file    Duree.cpp
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  définitions de la classe Duree
 *
 **/
#include <iostream>
#include <iomanip>   // setw()
#include "Duree.h"

using namespace nsUtil;
using namespace std;

#define DUREE nsUtil::Duree

DUREE::Duree  (const ULLong_t duree /* = ULLong_t (0) */) 
    : myDuree (duree) 
{ 
	normaliser ();
	
} // Duree()

DUREE::Duree  (const Duree & duree) 
    : myDuree (duree.getDuree ()) 
{ 
	normaliser ();
		
} // Duree()

DUREE::~Duree  (void) 
{ 
		
} // Duree()

void DUREE::normaliser (void)
{
	myDays    =  myDuree / 86400;
	myHours   = (myDuree % 86400) / 3600;
	myMinutes = (myDuree % 3600) / 60;
	mySeconds =  myDuree % 60;
	
} // normaliser()

ULLong_t DUREE::getDuree (void) const { return myDuree; }

void DUREE::display (void) const
{
	cout << '[' 
	     << setw (10) << myDays    << ':' 
	     << setfill ('0')
	     << setw (2)  << myHours   << " heure(s)"
	     << setw (2)  << myMinutes << " minute(s)"
	     << setw (2)  << mySeconds << " seconde(s)"
	     << setfill (' ')
             << ']';
		 
} // display()

void DUREE::incr (const ULLong_t delta /* = ULLong_t (0) */)
{
	myDuree += delta;
	normaliser ();
	
} // incr()

void DUREE::decr (const ULLong_t delta /* = ULLong_t (0) */)
{
	myDuree -= (delta > myDuree) ? myDuree : delta;
	
} // decr()

DUREE DUREE::operator + (const Duree & d) const
{
	return myDuree + d.myDuree;
	
} // operator +()

DUREE DUREE::operator - (const Duree & d) const
{
	return myDuree - (myDuree < d.myDuree ? myDuree : d.myDuree);
	
} // operator -()

bool DUREE::operator > (const Duree & d) const
{
	return myDuree > d.myDuree;
	
} // operator >()

bool DUREE::operator < (const Duree & d) const
{
	return myDuree < d.myDuree;
	
} // operator <()

bool DUREE::operator != (const Duree & d) const
{
	return myDuree != d.myDuree;
	
} // operator !=()

bool DUREE::operator == (const Duree & d) const
{
	return myDuree == d.myDuree;
	
} // operator ==()

#undef DUREE

M2103-TP2-Exo-3

Remarque préliminaire : cet exercice ne peut être effectué qu’après l’exercice précédent.
L’exercice nécessite l’utilisation de la fonction rand() qui a déjà été mise à votre disposition.

Lorsque vous en avez fini, récupérer les fichiers sources du projet DureeRelOps dans le nouveau projet DureeSortSearch.

Dans la fonction TestDuree() :

  1. déclarez la constante KDureeMax représentant la valeur maximale d’une durée (par exemple 1000000),
  2. déclarez le type CVDuree (vecteur de Durees) et Iter_t (itérateur de lecture (const_iterator)) et un vecteur de type CVDuree :
  3. saisissez au clavier le nombre de durées aléatoires à générer,
  4. générez ces durées dans l’intervalle [0, KDureeMax],
  5. en parcourant le vecteur avec un itérateur, affichez les durées générées sous la forme :
    [    xx:xx:xx:xx] = yyyyyyy
    

    yyyyyy est la valeur de la durée en secondes,

  6. triez le vecteur par durées décroissantes au moyen de la fonction standard sort() (#include <algorithm>),
  7. affichez de nouveau le contenu du vecteur (cette fois trié)
  8. dans une boucle jusqu’à fin de fichier, lisez au clavier une durée en secondes et affichez si la valeur est ou n’est pas dans le vecteur en utilisant la fonction de recherche adéquate.

M2103-TP2-Exo-3-Corrigé

TestDuree.cpp

/**
 *
 * \file     TestDureeRelops.cpp
 *
 * \authors  M. Laporte, D. Mathieu
 *
 * \date     01/02/2008
 *
 * \version  V1.0
 *
 * \brief    Test des operateurs de comparaison
 *
 **/
#include <iostream>
#include <iomanip>         // setw()
#include <vector>
#include <ctime>           // time()
#include <cstdlib>         // srand(), rand()
#include <algorithm>       // sort(), find()

using namespace std;
using namespace rel_ops;

#include "Duree.h"

using namespace nsUtil;

#define classdef typedef

namespace 
{
    typedef vector <Duree> CVDuree;
    typedef CVDuree::const_iterator Iter_t;
    ULLong_t KDureeMax (1000000);

    void testDuree (void)
    {
        srand (time (NULL));
        unsigned nbDurees;
        cout << "Nombre de Durees ? ";
        cin >> nbDurees;
        CVDuree vDurees;
        vDurees.reserve (nbDurees); 
        for (; nbDurees--;)
            vDurees.push_back (rand () % (KDureeMax + 1));
        for (Iter_t iter (vDurees.begin ()); iter != vDurees.end (); 
             ++iter)
        {
            iter->display ();
            cout << setw (7) << iter->getDuree () << endl;
        }
        sort (vDurees.begin (), vDurees.end ());
        for (Iter_t iter (vDurees.begin ()); iter != vDurees.end (); 
             ++iter)
        {
            iter->display ();
            cout << setw (7) << iter->getDuree () << endl;
        }
        while (true)
        {
            ULLong_t duree;
            cout << "duree a chercher ? ";
            cin >> duree;
            if (cin.eof ()) break;
            duree.display ();
            cout << (vDurees.find (vDurees.begin (), 
                                   vDurees.end (),
                                   Duree (duree)) == VDurees.end () 
                             ? " n'est pas " 
                             : " est"
                    )
                 << " dans le vecteur" << endl;           
        }
            
    } // testDuree()

} // namespace anonyme

int main (void)
{
    testDuree ();

    return 0;

} // main()

M2103-TP2-Exo-4

Partie d’un exercice donné en test le 01/02/2007

Un nombre rationnel est un nombre réel qui peut être mis sous la forme d’une fraction d’entiers.

Un objet de la classe Rationnel est destiné à manipuler des nombres rationnels.

Téléchargez le fichier
TestRationnel.cpp
.

Créez le projet RationnelV1.

Classe Rationnel

Dans les fichiers Rationnel.h et Rationnel.cpp, écrire la déclaration de la classe Rationnel, de l’espace de noms nsMath, et les définitions de ses fonctions membres.

La classe dont le diagramme de classe est
doit posséder :

  • deux données membres myNum et myDenom représentant le numérateur et le dénominateur de la fraction (entiers signés),

  • deux constructeurs, un par défaut et un par recopie,

  • la fonction membre display(), de profil suivant :

    void display (void) const;
    

    qui, dans le flux standard de sortie, affiche le numérateur et le dénominateur séparés par un ‘/‘ (sans espace), -3/7 par exemple,

  • la fonction membre simplifier(), locale à la classe.

    Les fractions comme -12/5 et 12/-5 par exemple sont mathématiquement équivalentes, mais seule la première est acceptée comme représentation interne,

    Les fractions comme 12/5 et –12/-5 par exemple sont mathématiquement équivalentes, mais seule la première est acceptée comme représentation interne.>

    La représentation interne des rationnels doit être la plus simple possible.

    Pour cela, il est nécessaire de simplifier la fraction en divisant le numérateur et le dénominateur par leur plus grand commun diviseur (PGCD).

    Il faut remarquer que :

    • la fraction 0/b peut être “simplifiée” en 0/1

    • le PGDC de deux nombres entiers peut être calculé par l’algorithme suivant :

      fonction PGCD (N1 : in entier_naturel,
                     N2 : in entier_naturel)
          renvoie entier_naturel
      debut
          declarer a : entier_naturel;
          a <- N1;
          declarer b : entier_naturel;
          b <- N2;
          jusqu_a (a vaut b)
          faire
              si (a < b)
                  b <- b - a;
              sinon
                  a <- a - b;
              fsi
          ffaire
      
          renvoie b;
      fin
      

      Dans l’espace de noms anonyme du fichier Rationnel.cpp, écrire une fonction PGDC(a,b) qui calcule le PGDC de deux entiers positifs.

      La valeur absolue d’un numérique peut être obtenue en utilisant la fonction standard de C++ abs().

  • ce qu’il faut pour rendre la classe Rationnel LessThanComparable et EqualityComparable,

  • les opérateurs +, -, * et /.

M2103-TP2-Exo-4-Corrigé

Rationnel.h

/**
 *
 * \file    Rationnel.h
 *
 * \authors M. Laporte, D. Mathieu
 *
 * \date    01/02/2008
 *
 * \version V1.0
 *
 * \brief   Declaration de la classe Rationnel (V1)
 *             Ajout des operateurs de relation
 *
 **/
#ifndef __RATIONNEL_H__
#define __RATIONNEL_H__

namespace nsMath
{
    class Rationnel 
    {
        int myNum;
        int myDenom;
 
        void simplify (void);

      public : 
        Rationnel (const int num = 0, const int denom = 1); 
        Rationnel (const Rationnel & r);

        void display (void) const;

        bool operator <       (const Rationnel & r)  const;
        bool operator ==      (const Rationnel & r)  const;

        Rationnel operator + (const Rationnel & r)  const;
        Rationnel operator - (const Rationnel & r)  const;
        Rationnel operator * (const Rationnel & r)  const;
        Rationnel operator / (const Rationnel & r)  const;

    }; // Rationnel 
    
} // namespace nsMath

#endif /*  __RATIONNEL_H__  */

Rationnel.cpp

/**
 *
 * \file    Rationnel.cpp
 *
 * \authors M. Laporte, D. Mathieu
 *
 * \date    07/12/2011
 *
 * \version V1.0
 *
 * \brief   Definition des methodes de la classe Rationnel 
 *             (version 1)
 *
 **/
#include 
#include 
#include     // abs()

#include "Rationnel.h"

#define RATIONNEL nsMath::Rationnel

using namespace std;
using namespace nsMath;

namespace
{
/*
    unsigned PGDC (const unsigned a, const unsigned b) 
    {
        if (a == b) return a; 
        if (a < b) return PGDC (a, b - a);
        if (a > b) return PGDC (b, a - b); 

    } // PGDC()
*/
    unsigned PGDC (unsigned a, unsigned b) 
    {
        for ( ; a != b; )
        {
            if (a < b)
                b -= a;
            else
                a -= b;
        }
        return a;

    } // PGDC()

} // namespace

RATIONNEL::Rationnel (const int num   /* = 0 */, 
                      const int denom /* = 1 */) 
    : myNum (num), myDenom (denom)
{
    simplify ();

} // Rationnel()

RATIONNEL::Rationnel (const Rationnel & r) 
    : myNum (r.myNum), myDenom (r.myDenom) {}

void RATIONNEL::display (void) const
{
    cout << myNum << '/' << myDenom;

} // display()

void RATIONNEL::simplify (void) 
{
    if (myDenom < 0)
    {
        myNum   = -myNum;
        myDenom = -myDenom;
    }
    int pgdc = (myNum == 0) ? myDenom 
                            : PGDC (abs (myNum), abs (myDenom));

    myNum   /= pgdc;
    myDenom /= pgdc;

} // simplify() 

bool RATIONNEL::operator < (const Rationnel & r) const 
{
    return myNum * r.myDenom < myDenom * r.myNum;

} // operator <

bool RATIONNEL::operator == (const Rationnel & r) const 
{
    return myNum == r.myNum && myDenom == r.myDenom;

} // operator ==

RATIONNEL RATIONNEL::operator + (const Rationnel & r) 
    const  
{
    return Rationnel (myNum   * r.myDenom + r.myNum * myDenom, 
                      myDenom * r.myDenom); 

} // operator +

RATIONNEL RATIONNEL::operator - (const Rationnel & r) 
    const  
{
    return Rationnel (myNum   * r.myDenom - r.myNum * myDenom, 
                      myDenom * r.myDenom); 

} // operator -

RATIONNEL RATIONNEL::operator * (const Rationnel & r) 
    const  
{
    return Rationnel (myNum   * r.myNum, 
                      myDenom * r.myDenom); 

} // operator *

RATIONNEL RATIONNEL::operator / (const Rationnel & r) 
    const  
{
    return Rationnel (myNum * r.myDenom, myDenom * r.myNum); 

} // operator /

#undef RATIONNEL