M2103-TP1-Exo-1

L’objectif de cet exercice est de construire une ébauche d’une classe permettant de gérer une durée de temps (un délai), exprimé soit en secondes, soit en jours, heures, minutes et secondes.

Les normes IUT de programmation C++ devront être respectées : identificateurs des données membres (myData), identificateurs des paramètres (Data, terminaisons des classes}; // CX, …).

Création du projet

Créez le projet DureeDeBase (avec QT Creator).

Etape 1

Dans l’espace de noms anonyme du fichier main.cpp, déclarer la classe Duree dont le diagramme de classe est

, qui possède les données membres suivantes :

  • la durée en secondes (toujours positive ou nulle, et la plus grande possible),

  • le nombre de jours, d’heures, de minutes et de secondes correspondants (choisir les types les mieux adaptés).

et les fonctions membres suivantes :

  • un constructeur dont l’unique paramètre est le nombre de secondes de la durée,

  • une fonction membre display() qui affiche à l’écran la durée sous la forme suivante (sans retour chariot, pour pouvoir compléter l’affichage) :

          0 jour(s)  0 heure(s)  1 minute(s) 40 seconde(s)
         12 jour(s) 23 heure(s) 59 minute(s)  9 seconde(s)
    

    Comme le montre l’exemple ci-dessus, prévoir pour les zones numériques un format tel qu’elles soient alignées verticalement (rappel en utilisant le manipulateur standard setw().

    On pourra simplifier l’affichage en utilisant les unités h., j. min., s. au lieu de jour, heure, minute, seconde.

  • une fonction membre normaliser() qui transforme en jours, heures, etc., toute durée exprimée en secondes.

    Cette fonction ne devrait être accessible qu’à des fins internes.

Les définitions (corps) de toutes les fonctions membres devront être faites en dehors de la déclaration de la classe.

Attention à utiliser à bon escient le qualificatif const.

Avant de continuer à développer cette classe, tester ces trois premières fonctions membres.

Pour cela, écrire la fonction testDureeDeBase() qui, dans une boucle, saisit au clavier une durée exprimée en secondes (jusqu’à une valeur nulle), construit un objet de la classe Duree initialisé à la valeur lue et l’affiche à l’écran.

Compiler et tester.

Lorsque les résultats vous sembleront justes, vous devez ouvrir un terminal et vous placer dans le répertoire où se trouve l’exécutable de votre projet.

Téléchargez-y le fichier FichDurees.

Testez à nouveau votre programme en redirigeant le fichier FichDurees sur le flux d’entrée standard et comparez vos résultats avec ceux qui sont indiqués ci-dessous.

Seconde étape

Vous pouvez maintenant enrichir la classe avec :

  • la fonction membre getDuree() qui renvoie la valeur de la donnée membre correspondante,

  • les fonctions membres incr() et decr() qui augmentent ou diminuent la durée de l’objet de la valeur delta passée en paramètre.

    On considère pour le moment que si delta est supérieur à la valeur courante de la durée, le résultat de decr(Delta) est une durée nulle.

En fin de fonction testDureeDeBase(), ajoutez le code ci-dessous.

Duree d1 (0);
d1.incr (1);
cout << "Nbre sec. " << setw (6) << d1.getDuree ()
     << ", soit : ";
d1.display ();
cout << '\n';

d1.decr (1);
cout << "Nbre sec. " << setw (6) << d1.getDuree ()
     << ", soit : ";
d1.display ();
cout << '\n';

d1.incr (3662);
cout << "Nbre sec. " << setw (6) << d1.getDuree ()
     << ", soit : ";
d1.display ();
cout << '\n';

d1.decr (10000);
cout << "Nbre sec. " << setw (6) << d1.getDuree ()
     << ", soit : ";
d1.display ();
cout << '\n';

N’oubliez pas de sauvegarder tous vos fichiers sources sur github.

M2103-TP1-Exo-1-Corrigé


/**
*
* \file    Duree.cpp
*
* \authors M. Laporte
*
* \date    02/04/2018
*
* \version V2.0
*
* \brief  classe Duree et test de cette classe
*
**/
#include <iostream>
#include <iomanip>   // setw()

using namespace std;

typedef unsigned long long ULLong_t;

namespace
{
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 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

Duree::Duree  (const ULLong_t duree) : myDuree (duree)
{
normaliser ();

} // Duree()

void Duree::normaliser (void)
{
myDays    =  myDuree / 86400;
myHours   = (myDuree % 86400) / 3600;
myMintes  = (myDuree % 3600) / 60;
mySeconds =  myDuree % 60;

} // normaliser()

ULLong_t getDuree (void) const { return myDuree; }

void Duree::display (void) const
{
cout << setw (10) << myDays    << " jour(s)"
<< setw (3)  << myHours   << " heure(s)
<< setw (3)  << myMinutes << " minute(s)
<< setw (3)  << mySeconds << " seconde(s);

} // display()

void Duree::incr (const ULLong_t delta /* = ULLong_t (0) */)
{
myDure += delta;
normaliser ();

} // incr()

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

} // decr()

void testDureeDeBase (void)
{
ULLong_t oneDuree;
for (cin >> oneDuree; ! cin.eof (); cin >> oneDuree)
{
Duree duree (oneDuree);
duree.display;
cout << endl;
}
Duree d1 (0);
d1.incr (1);
cout &lt;&lt; "Nbre sec. " &lt;&lt; setw (6) &lt;&lt; d1.getDuree ()
&lt;&lt; ", soit : ";
d1.display ();
cout &lt;&lt; '\n';

d1.decr (1);
cout &lt;&lt; "Nbre sec. " &lt;&lt; setw (6) &lt;&lt; d1.getDuree ()
&lt;&lt; ", soit : ";
d1.display ();
cout &lt;&lt; '\n';

d1.incr (3662);
cout &lt;&lt; "Nbre sec. " &lt;&lt; setw (6) &lt;&lt; d1.getDuree ()
&lt;&lt; ", soit : ";
d1.display ();
cout &lt;&lt; '\n';

d1.decr (10000);
cout &lt;&lt; "Nbre sec. " &lt;&lt; setw (6) &lt;&lt; d1.getDuree ()
&lt;&lt; ", soit : ";
d1.display ();
cout &lt;&lt; '\n';

} // testDureeDeBase()

} // namespace

int main (void)
{
testDureeDeBase ();
return 0;

} // main()

M2103-TP1-Exo-2

Création du projet

Créez le projet ModuleProf (avec QT Creator).

Etape 1

Dans l’espace de noms anonyme du fichier TestModuleProf.cpp, déclarer les classes Module et Prof définie par le
diagramme UML
:

, qui possède les caractéristiques suivantes :

  • Les références aux modules enseignés par un professeur seront rangés dans un
    vector <Module *>.

  • Le constructeur de la classe Prof aura en paramètre uniquement son nom.

  • Les références aux professeurs dispensant un module seront rangés dans un
    vector <Prof *>.

  • Le constructeur de la classe Module aura en paramètre uniquement son nom.

  • La fonction addModule() de la classe Prof ajoute au vector <Module *> le module passé en paramètre.
    Ce paramètre est un pointeur sur un Module (non représentable en UML).

  • La fonction addProf() de la classe Module ajoute au vector <Prof *> le module passé en paramètre.
    Ce paramètre est un pointeur sur un Prof (non représentable en UML).

  • La fonction display() de la classe Prof affiche les noms de chacun des modules qu’il dispense, à raison d’un par ligne.

  • La fonction display() de la classe Module affiche les noms de chacun des professeurs qui le dispense,
    à raison d’un par ligne.

Dans l’espace de nom anonyme écrire la fonction TestModuleProf() qui :

  • crée, un vector <Module *> (4 ou 5 suffiront), en saisissant les noms des modules au clavier (ne pas oublier d’allouer de la place).

  • crée, un vector <Prof *> (4 ou 5 suffiront), en saisissant les noms des professeurs au clavier (ne pas oublier d’allouer de la place).

  • Ajoute à chaque professeur 1 ou 2 modules qu’il dispense.

  • Ajoute à chaque module 1 ou 2 professeurs qui l’enseigne.

  • Affiche le nom de chaque professeur suivi de la liste de tous les modules dans lesquels il intervient.

  • Affiche le nom de chaque module suivi de la liste de tous les professeurs qui le dispensent.

  • Restitue l’espace alloué dans chacun des 2 vectors.

N’oubliez pas de sauvegarder tous vos fichiers sources sur github.

M2103-TP1-Exo-2-corrigé

/**
 *
 * \file    ModuleProf.cpp
 *
 * \authors M. Laporte
 *
 * \date    06/03/2018
 *
 * \version V1.0
 *
 * \brief   Classes Module et Prof, déclarations, définitions et tests
 *
 **/
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include <vector>

using namespace std;

namespace 
{

    class Prof;

    class Module 
    {
            std::string          myName;
            std::vector <Prof *> myProfs;
            
        public:

            Module (const string & Name = string ());
            
            string getName (void) const;
            void   display (void) const;
            
            void addProf (/*const*/ Prof * prof);
            void setName (const string & Name);
            
    }; // Module

    class Prof 
    {
            std::string       myName;
            vector <Module *> myModules;
       public:

            Prof (const string & Name = string ());
                       
            string getName (void) const;
            void   display (void) const;
            
            void addModule (/*const*/ Module * module);
            void setName   (const string & Name);
            
    }; // Prof

// Module

    Module::Module (const string & Name /* = string () */) : myName (Name) {}

    string Module::getName (void) const { return myName; }

    void   Module::display (void) const
    {
        for (Prof * pProf : myProfs)
            cout << pProf->getName () << endl;
        
    } // display()

    void   Module::setName (const string & Name) { myName = Name; }

    void   Module::addProf (/*const*/ Prof * pProf)  { myProfs.push_back (pProf); }

// Prof

    Prof::Prof (const string & Name /* = string () */) : myName (Name) {}

    string Prof::getName (void) const { return myName; }

    void   Prof::display (void) const
    {
        for (Module * pModule : myModules)
            cout << pModule->getName () << endl;
        
    } // display()

    void   Prof::setName (const string & Name) { myName = Name; }

    void   Prof::addModule (/*const*/ Module *pModule)  { myModules.push_back (pModule); }

// Tests

    void testModuleProf (void) 
    {
        vector <Module *> modules;
        modules.resize(5);
        
        vector <Prof *>   profs;
        profs.resize(5);
        
        // Création des modules
        
        for (unsigned i (0); i < 5; ++i) 
        {
            string module;
            cout << "Veuillez saisir un nom de Module : (pas d'espace dans le nom)" << endl;
            cin >> module;
            modules [i] = new Module (module);
        }
        // Création des profs
        
        for (unsigned i (0); i < 5; ++i) 
        {
            string prof;
            cout << "Veuillez saisir un nom de Prof : (pas d'espace dans le nom)" << endl;
            cin >> prof;
            profs [i] = new Prof (prof);
        }
        
        // création des associations, attention si un prof est lié
        // à un module, ce module doit être lié à ce prof
        // Le prof 0 sera lié à tous les modules, le 1 à tous sauf le premier ...
        
        for (unsigned numProf (0); numProf < profs.size (); ++numProf)
        {
            for (unsigned numModule (numProf); numModule < modules.size (); ++numModule)
            {
                profs   [numProf]   ->addModule (modules [numModule]);
                modules [numModule]->addProf   (profs   [numProf]);
            }
        }
        
        // affichages des profs avec leur modules assiciés
        
        for (const Prof * prof : profs)
        {
            cout << "Nom de professeur : " << prof->getName () << endl;
            cout << "Liste des modules associés :" << endl;
            prof->display ();
            cout << endl;
        }
        
        // affichages des modules avec leur profs assiciés
        
        for (const Module * module : modules)
        {
            cout << "Nom du module : " << module->getName () << endl;
            cout << "Liste des professeurs associés :" << endl;
            module->display ();
            cout << endl;
        }
        
        // restitution de l'espace (on remarquera la symétrie avec la création)
        
        for (unsigned i(0); i < 5; ++i)
        {
            delete profs [i];
            // on aurait pu faire une boucle spécifique pour la ligne qui suit
            delete modules [i];
        }
        
    } // testModuleProf()
    
    
    // plus d'allocation dynamique
    
    void testModuleProfV2 (void) 
    {
        vector <Module> modules;
        modules.resize(5);
        
        vector <Prof>   profs;
        profs.resize(5);
        
        // Création des modules
        
        for (unsigned i (0); i < 5; ++i) 
        {
            string module;
            cout << "Veuillez saisir un nom de Module : (pas d'espace dans le nom)" << endl;
            cin >> module;
            modules [i] = module;
        }
        // Création des profs
        
        for (unsigned i (0); i < 5; ++i) 
        {
            string prof;
            cout << "Veuillez saisir un nom de Prof : (pas d'espace dans le nom)" << endl;
            cin >> prof;
            profs [i] = prof;
        }
        
        // création des associations, attention si un prof est lié
        // à un module, ce module doit être lié à ce prof
        // Le prof 0 sera lié à tous les modules, le 1 à tous sauf le premier ...
        
        for (unsigned numProf (0); numProf < profs.size (); ++numProf)
        {
            for (unsigned numModule (numProf); numModule < modules.size (); ++numModule)
            {
                profs   [numProf]   .addModule (& (modules [numModule]));
                modules [numModule].addProf   (& (profs   [numProf]));
            }
        }
        
        // affichages des profs avec leur modules assiciés
        
        for (const Prof & prof : profs)
        {
            cout << "Nom de professeur : " << prof.getName () << endl;
            cout << "Liste des modules associés :" << endl;
            prof.display ();
            cout << endl;
        }
        
        // affichages des modules avec leur profs assiciés
        
        for (const Module & module : modules)
        {
            cout << "Nom du module : " << module.getName () << endl;
            cout << "Liste des professeurs associés :" << endl;
            module.display ();
            cout << endl;
        }
        
        // restitution de l'espace devenue inutile
        
    } // testModuleProfV2()
    
 } // namespace

int main()
{
    /*    * / testModuleProf   (); /*    */
    /*    */  testModuleProfV2 (); /*    */
    return 0;
}

M2103-TP1-Exo3

Remarque préliminaire : cet exercice ne peut être effectué qu’après l’exercice 1 de ce même TP

Si la classe Duree est susceptible d’être utilisée dans plus d’un seul fichier, ce qui est déjà le cas, elle doit en être extraite et mise à la disposition de tout utilisateur.

De ce fait elle ne peut plus appartenir à un espace de noms anonyme.

Comme la norme C++ préconise de ne pas utiliser d’identificateurs globaux, il faut donc placer la classe Duree (déclaration et définition) dans un espace de noms nommé.

La notion de “durée” étant assez générale et non spécifique à un domaine particulier, nous la ferons entrer dans la catégorie des outils et nous la placerons dans l’espace nsUtil.

De plus, la déclaration de la classe sera placée dans un fichier .h susceptible d’être inclus dans tout programme utilisant cette classe.

Les définitions des méthodes seront au contraire regroupées dans un fichier .cpp.

Lorsque le code sera stabilisé (plus d’ajouts ni de modifications) il sera compilé séparément (avec production d’un fichier objet .o) et ajouté à une bibliothèque (library, fichier archive .a).

Créer le projet DureeCompilSeparee.

Y recopier le fichier DureeDeBase.cpp dans les fichiers Duree.h, Duree.cpp et TestDuree.cpp.

Dans le fichier Duree.h, extraire tout ce qui ne concerne pas la déclaration de la classe Duree (voir l’amphi correspondant).
Mettre la classe dans l’espace de noms nsUtil.
Ajouter les directives d’inclusion conditionnelle.

Dans le fichier Duree.cpp, placer tous les corps des fonctions membres (elles appartiennent maintenant à l’espace de noms nsUtil).

Inclure le fichier Duree.h.

Extraire tout ce qui ne concerne pas la définition de la classe Duree.

Du fichier TestDuree.cpp, supprimer tout ce qui concerne la classe Duree et le remplacer par l’inclusion du fichier Duree.h.

Au début de la fonction testDuree(), ajouter la déclaration d’un vector de Duree.

Modifier la boucle de lecture des durées au clavier, pour stocker les objets Duree créés dans le vecteur.

En fin de lecture au clavier, afficher le contenu du vecteur.

Compiler et tester.

N’oubliez pas de sauvegarder tous vos fichiers sources sur github.

M2103-TP1-Exo-3-corrigé

Fichier Duree.h

/**
 *
 * \file    Duree.h
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  déclarations de la classe Duree
 *
 **/
 
 #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 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

} // nsUtil

#endif /* __DUREE_H__ */

Fichier 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) : myDuree (duree) 
{ 
	normaliser ();
	
} // 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    << " jour(s)"
             << setw (3)  << myHours   << " heure(s)"
	     << setw (3)  << myMinutes << " minute(s)"
	     << setw (3)  << mySeconds << " seconde(s)";
		 
} // 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()

#undef DUREE

Fichier testDuree.cpp

 
/**
 *
 * \file    testDuree.cpp
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  test de la classe Duree
 *
 **/
#include <iostream>
#include <iomanip>   // setw()
#include <vector>

#include "Duree.h"

using namespace std;
using namespace nsUtil;

namespace
{
	void testDuree (void)
	{
		vector <Duree> vDurees;
		
		ULLong_t oneDuree;
		for (cin >> oneDuree; ! cin.eof (); cin >> oneDuree)
		{
		    vDurees.push_back (oneDuree);
		}
		for (const Duree & duree : vDurees)
		{
		    duree.display ();
			cout < endl;
		}
		Duree d1 (0);
		d1.incr (1);
		cout << "Nbre sec. " << setw (6) << d1.getDuree ()
			 << ", soit : ";
		d1.display ();
		cout << '\n';

		d1.decr (1);
		cout << "Nbre sec. " << setw (6) << d1.getDuree ()
			 << ", soit : ";
		d1.display ();
		cout << '\n';

		d1.incr (3662);
		cout << "Nbre sec. " << setw (6) << d1.getDuree ()
			 << ", soit : ";
		d1.display ();
		cout << '\n';

		d1.decr (10000);
		cout << "Nbre sec. " << setw (6) << d1.getDuree ()
			 << ", soit : ";
		d1.display ();
		cout << '\n';		
					
	} // testDuree()
	
} // namespace

int main (void)
{
	testDuree ();
	return 0;
	
} // main()

M2103-TP1-Exo4

Remarque préliminaire : cet exercice ne peut être effectué qu’après l’exercice 3 de ce même TP
CDuree – Compilation séparée.

Construire le projet DureeConstrDfltCopyDestr.

Recopier les sources du projet DureeCompilSeparee dans le répertoire Sources du projet DureeConstrDfltCopyDestr.

Fonction display

Afin de rendre l’affichage plus concis, remplacer l’affichage initial, de la forme :

    12 jour(s)  2 heure(s)  3 minute(s) 55 seconde(s)

par

[    12:02:03:55]

Pour cela, vous devez utiliser le manipulateur setfill() en lui passant en paramètre le caractère de remplissage à gauche du chiffre le plus significatif : ' ' pour les jours, et '0' pour les autres valeurs.

Remarques

  1. setfill() a un effet permanent, jusqu’à la prochaine modification explicite du caractère de remplissage.

    Ceci implique qu’après l’avoir modifié, pensez à le restaurer à la valeur par défaut (l’espace).

  2. Lire aussi la fonction fill()

Destructeur

A la classe Duree, ajouter le destructeur qui se contente d’afficher le contenu de l’objet détruit (fonction display())).

Ajouter au constructeur l’affichage du contenu de l’objet construit (fonction display())).

Dans la fonction testCDuree(), commencer par redimensionner (resize()) le vecteur (vector) à 10 éléments (cela doit suffire pour le fichier FichDurees) et remplacer la fonction push_back() par une écriture indicée.

Compiler et tester.

Vous constatez une erreur de compilation.

Les raisons sont expliquées par le fonctionnement du constructeur par défaut et par celui de la fonction resize()‘ des cours consacrés à la classe vector.

Constructeur par défaut

Ajouter des valeurs par défaut aux paramètres du constructeur et des fonctions incr() et decr().

Compiler et tester.

Identifier les affichages provoqués par les appels de tous les destructeurs.

Constructeur par recopie

A la classe Duree, ajouter la surcharge du constructeur par recopie.

Y ajouter provisoirement un affichage permettant de montrer qu’il est appelé.

Avant la fonction testDuree(), ajouter dans l’espace de noms anonyme la fonction suivante :

void fct (Duree durDur)
{
	cout << "Affichage de durDur : ";
	durDur.afficher ();
	cout << '\n'; 

} // Fct()

Tester avec le fichier FichDurees téléchargé précédemment.

Analyser et comprendre tous les affichages.

N’oubliez pas de sauvegarder tous vos fichiers sources sur github.

M2103-TP1-Exo-4-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

} // 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 ();
    cout << "duree construite : ";
    display ();
    cout << endl;	
	
} // Duree()

DUREE::Duree  (const Duree & duree) 
    : myDuree (duree.getDuree ()) 
{ 
    normaliser ();
    cout << "duree construite par recopie : ";
    display ();
    cout << endl;	
	
} // Duree()

DUREE::~Duree  (void) 
{ 
    cout << "duree détruite : ";
    display ();
    cout << endl;	
	
} // 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()

#undef DUREE

testDuree.cpp

 
/**
 *
 * \file    testDuree.cpp
 *
 * \authors M. Laporte
 *
 * \date    02/04/2018
 *
 * \version V2.0
 *
 * \brief  test de la classe Duree
 *
 **/
#include <iostream>
#include <iomanip>   // setw()
#include <vector>

#include "Duree.h"

using namespace std;
using namespace nsUtil;

namespace
{
    void testDuree (void)
    {
        vector <Duree> vDurees;
		
        ULLong_t oneDuree;
        for (cin >> oneDuree; ! cin.eof (); cin >> oneDuree)
        {
            vDurees.push_back (oneDuree);
        }
        for (const Duree & duree : vDurees)
        {
            duree.display ();
            cout << endl;
        }
        Duree d1 (0);
        d1.incr (1);
        cout << "Nbre sec. " << setw (6) << d1.getDuree ()
             << ", soit : ";
        d1.display ();
        cout << '\n';

        d1.decr (1);
        cout << "Nbre sec. " << setw (6) << d1.getDuree ()
             << ", soit : ";
        d1.display ();
        cout << '\n';

        d1.incr (3662);
        cout << "Nbre sec. " << setw (6) << d1.getDuree ()
             << ", soit : ";
        d1.display ();
        cout << '\n';

        d1.decr (10000);
        cout << "Nbre sec. " << setw (6) << d1.getDuree ()
	     << ", soit : ";
        d1.display ();
        cout << '\n';		
					
    } // testDuree()
	
} // namespace

int main (void)
{
	testDuree ();
	return 0;
	
} // main()