/**
*
* \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;
    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()

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 << "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';

} // testDureeDeBase()

} // namespace

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

} // main()

Lire la suite →

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.

/**
 *
 * \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;
}

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.

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()

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.

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   << ':'
	 << setw (2)  << myMinutes << ':'
	 << setw (2)  << mySeconds << ':'
	 << 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()