Remarques préliminaires :

• La lecture préalable du document " Classe CDumpable ou CEditable ?" (au minimum les paragraphes Introduction,  Surcharge de l'injecteur <<,  Classe CEditable et  Edition de classes complexes), est indispensable à la réalisation du premier exercice.
• Tous les exercices de ce TP doivent être effectués dans le répertoire dirutilit qui sera considéré comme répertoire courant.
• Au cours de ce TP, différents "outils" d'intérêt général seront développés, qui seront utilisés ultérieurement (jusqu'en TP de Système et de réseau de deuxième année). En conséquence, ils ne seront pas placés dans le répertoire courant mais dans des répertoires spécialisés (à créer dès maintenant) :
  • tp/tpC++/include qui contiendra en particulier les fichiers de déclarations à inclure (fichiers .h et .hxx),
  • tp/tpC++/util qui contiendra entre autres les fichiers sources à compiler séparément.
• Rappel : Chemins d'accès aux sources des corrigés.

Sommaire

Classe CEditable

exo_01

• Liste des fichiers créés ou modifiés : exo_01.cxx, CEditable.h, CEditable.hxx, Makefile_01

    Dans l'espace de noms anonyme du fichier exo_01.cxx, recopier la fonction suivante :
 

void Contenu (const CEditable & Ed) { cout << Ed << endl; }

    Ajouter deux classes CA et CB, dérivées de CEditable, qui ne se distinguent que par leur fonction virtuelle _Edit().

    Dans la fonction Exo_01(), instancier les classes CA et CB, et éditer les deux objets au moyen de la fonction Contenu().

    Ecrire un fichier Makefile_01. Les fichiers CEditable.h et CEditable.hxx étant dans le répertoire include, différent du répertoire courant, il faut :

• indiquer le chemin d'accès à ces fichiers dans les dépendances,
• utiliser l'option -I de la commande g++.

    Pour simplifier l'écriture, on peut ajouter dans le fichier Makefile_01 la macro suivante :
 

INCLUDE = $(HOME)/tp/tpC++/include

    Compiler et tester. Vous devez constater que la fonction Contenu() affiche bien le contenu de l'objet réel passé en paramètre effectif.

Corrigés : CEditable.h      -      CEditable.hxx      -      exo_01.cxx      -      Makefile_01

Sommaire

Classe CException

exo_02

• Liste des fichiers créés ou modifiés : exo_02.cxx, CException.h, CException.hxx, CException.cxx, INCLUDE_H, MakeUtil, Makefile_02

    Dans une application, il est probable que nous utilisions simultanément plusieurs classes susceptibles de lever des exceptions. Si nous voulons pouvoir intercepter sélectivement les exceptions en provenance de chacune d'elles, par une succession de blocs catch, il est nécessaire que chacune de ces exceptions soit spécifique de la classe qui la lève.

    C'est pourquoi, dans l'exo_05 du TP 6 sur les classes, nous avons montré comment développer la classe CException interne à la classe CDuree. Cependant, en première approximation, toutes les classes d'exceptions sont identiques, et il est inutile de redévelopper leur code à chaque fois (données membres m_Libelle et m_CodErr, et fonctions membres). Cette contradiction est levée par la technique suivante :

• une classe générale CException, appartenant à l'espace de noms nsUtil, est écrite une fois pour toutes,
• dans chaque classe est redéfinie une nouvelle classe CException par :
   

  namespace nsUtil {    class CException    {        // ...    }; // CException } // nsUtil namespace nsWorking {    class CDuree    {      public :        typedef nsUtil::CException CException;        // ...    }; // CDuree } // nsWorking

    Un second problème subsiste : dans la classe écrite au TP 6, le code d'erreur m_CodErr est d'un type énumératif CodErr_t spécifique de CDuree. Si la classe CException est sortie de la classe CDuree, ce type n'est plus défini.

    Une solution consisterait à rendre la classe CException générique, avec le type CodErr_t comme paramètre de généricité. Cela présente deux inconvénients :

• le premier est que chaque édition de m_CodErr dans un flux par l'opérateur << provoque un warning signalant que cet opérateur n'a pas été surchargé par ce type (le compilateur utilise alors l'opérateur d'injection d'entier),
• le second est que les types énumératifs en C++ sont en fait des sous-types d'entiers, et que l'instanciation de la classe générique CException par des types très voisins est un peu artificielle.

    Nous retiendrons donc la solution suivante : la donnée membre m_CodErr est de type entier (int), mais les valeurs auxquelles elle sera initialisée sont des constantes de types énumératifs (anonymes) spécifiques de chaque classe.

    Puisque les exceptions sont en général affichées, il est naturel de faire dériver la classe CException de CEditable.

    En les plaçant dans les fichiers include/CException.h, include/CException.hxx et util/CException.cxx, de nombreuses lignes de code de CException peuvent être récupérées à partir des fichiers dirptr/CDuree.*. Les modifications essentielles à effectuer sont les suivantes :

• ajouter la dérivation publique de CEditable,
• remplacer le type CodErr_t par le type int,
• ajouter un destructeur virtuel à la classe, qui est une classe virtuelle car elle comporte une fonction virtuelle. Cet ajout aurait dû être fait dans les TPs précédents mais les notions de classe virtuelle et de polymorphisme n'avaient pas été abordées,
• ajouter la fonction protégée _Edit() (car elle doit pouvoir être appelée à partir des futures classes filles),
• modifier le type de retour de l'accesseur GetCodErr(),
• en profiter pour modifier aussi le type de retour de l'accesseur GetLibelle() : éviter de construire une chaîne intermédiaire dans la fonction (réfléchir !...),
• supprimer les fichiers inclus inutiles,
• ajouter une constante CstNoError pour pouvoir donner une valeur initiale au paramètre du constructeur ( ==> constructeur par défaut).

    Les fonctions constructeur, destructeur, what(), GetLibelle() et GetCodErr() peuvent être placées dans le fichier .hxx car elles sont très courtes. En revanche, la fonction _Edit() doit être placée dans le fichier .cxx (4 injections = 4 appels de fonctions)

Fichier include/INCLUDE_H

    Ce fichier est destiné à contenir les macros d'utilisation courante dans les fichiers Makefile, en particulier :

• les macros UTIL et INCLUDE correspondant aux chemins d'accès absolus (à partir de votre répertoire racine) aux répertoires tpC++/util et tpC++/include,
• les macros des dépendances des fichiers .h et .hxx contenus dans le répertoire include (pour le moment les macros CEDITABLE_HXX, CEDITABLE_H, CEXCEPTION_HXX et CEXCEPTION_H).
• la macro COMPILER suivante :
   

  COMPILER = g++ -c -I$(INCLUDE) -Wall $*.cxx;

  qui peut remplacer les commandes de compilation de la plupart des fichiers sources (voir macros standard de la commande make).

Fichier Makefile_02

    Avant tout travail sur ce fichier, il est fortement recommandé de (re)-lire le document Commande Unix make (le paragraphe intitulé : "Arguments de la commande make" peut être sauté pour le moment).

    Puis recopier le fichier Makefile_01 dans Makefile_02. Remplacer la macro INCLUDE par l'inclusion du fichier INCLUDE_H :
 

include $(HOME)/tp/tpC++/include/INCLUDE_H

    Ajouter la cible permettant l'éventuel déclenchement (lancement du fichier MakeUtil) de la compilation des fichiers du répertoire util.

Fichier exo_02.cxx

    Ce programme est seulement destiné à vérifier que les différents fichiers ci-dessus sont justes, et que le polymorphisme est correctement implémenté pour les classes CEditable et CException.

    Dans l'espace de noms anonyme du fichier exo_02.cxx, dériver la classe CExcFille de CException, lui ajouter directement en inline :

• la fonction _Edit(), qui complète l'édition de sa classe mère par un message spécifique (n'importe quoi).
• un constructeur permettant de construire l'objet de la classe mère (passage d'un libellé et d'une constante entière).

    Dans la fonction Exo_02(), lever une exception de la classe CExcFille.

    Compiler et tester. Vérifier que la fonction main() affiche bien l'exception levée.

Corrigés : exo_02.cxx      -      Makefile_02      -      INCLUDE_H      -      CException.h      -      CException.hxx      -      MakeUtil      -      CException.cxx

Sommaire

Classe CDuree

exo_03

• Liste des fichiers créés ou modifiés : exo_03.cxx, CDuree.h, CDuree.hxx, CDuree.cxx, Makefile_03

    La classe CDuree écrite au cours des TPs précédents (en particulier dans l'exo_04 du TP 6 : les classes), peut être allégée grâce aux nouvelles classes utilitaires développées ci-dessus : CEditable et CException.

    Recopier les fichiers dirlstsimple/CDuree.* dans le répertoire courant. Effectuer les modifications suivantes :

• rendre la classe CDuree "éditable",
• remplacer la classe CException par un "renommage" local,
• rendre anonyme le type énumératif des codes d'erreurs, et supprimer la constante CstNoError (Attention : les autres constantes doivent prendre les valeurs suivantes),
• ajouter la fonction protégée _Edit(),
• supprimer la fonction Afficher() et l'opérateur <<,
• rendre explicite le constructeur de CDuree. En effet, il peut être dangereux que le compilateur prenne l'initiative de convertir tout entier en CDuree, dans des circonstances qui pourraient ne pas avoir été prévues par le développeur,
• ajouter un destructeur vituel. En effet, la classe CDuree est devenue virtuelle, après sa dérivation de la classe CEditable, elle-même virtuelle.

    Recopier le fichier Makefile_02 dans Makefile_03. Ajouter les macros CDUREE_H et CDUREE_HXX, et la compilation de CDuree.cxx.

    Recopier le fichier dirclass/exo_04.cxx dans exo_03.cxx et renommer la fonction Exo_04() en Exo_03(). Ajouter en fin de fonction Exo_03() des instructions qui lèvent les différentes exceptions possibles dans la classe CDuree. Les traiter localement, puis relever la dernière.

    Recopier le fichier dirclass/FichDurees dans le répertoire courant.

    Compiler et tester. Vérifier que la dernière exception est correctement interceptée par la fonction main().

Corrigés : exo_03.cxx      -      Makefile_03      -      CDuree.h      -      CDuree.hxx      -      CDuree.cxx

Sommaire

Classe CPtrIdent

exo_04

• Liste des fichiers créés ou modifiés : exo_04.cxx, CCptIdent.h, CCptIdent.hxx, CCptIdent.cxx, Makefile_04

    Dans le prochain TP, nous aurons à utiliser une classe formée d'une paire d'informations :

• une chaîne de caractères,
• sa fréquence absolue d'apparitions (c'est-à-dire son nombre d'occurrences).

    Dans les fichiers CCptIdent.h et CCptIdent.hxx, écrire la classe CCptIdent, de l'espace de noms nsWorking, ayant les caractéristiques suivantes :

• elle est éditable,
• la donnée membre m_Value de type string est initialisée à la construction,
• le compteur m_Freq associé est initialisé à zéro à la construction,
• elle offre :
  • un constructeur conforme aux indications ci-dessus. Bien que non nécessaire dans ce contexte, ce constructeur devra être un constructeur par défaut, pour pouvoir être utilisé dans les exercices ultérieurs,
  • un destructeur virtuel (la classe est virtuelle à cause de la classe mère virtuelle CEditable),
  • un accesseur pour chaque donnée membre. Comme précédemment, éviter de construire une chaîne intermédiaire dans la fonction GetValue() (réfléchir !...),
  • une surcharge des opérateurs de pré- et post-incrémentation qui incrémentent d'une unité le compteur m_Freq,
  • une surcharge de l' opérateur de relation < : un objet CCptIdent est inférieur à un autre si la chaîne (m_Value) qu'il contient est inférieure à la chaîne de l'autre objet,
  • une surcharge de l'opérateur d'égalité ==,
  • une surcharge de la fonction virtuelle _Edit(), qui doit afficher un objet CCptIdent sous la forme :
     

    chaine [fréquence]

    Dans la fonction Exo_04() du fichier exo_04.cxx, créer un vector de CCptIdent, ouvrir un fichier source pas trop long (par exemple CCptIdent.h). Dans une boucle jusqu'à fin de fichier :

• lire une chaîne de caractères (string),
• la rechercher dans le vector au moyen de la fonction find() (générique de la bibliothèque standard, déclarée dans <algorithm>, décrite dans la Documentation SGI : find() fournie) :
  • si elle est présente, incrémenter le compteur correspondant,
  • si elle est absente, l'ajouter en fin du vector.

    Trier le vector dans l'ordre croissant (fonction sort() générique de la bibliothèque standard, déclarée dans <algorithm>, décrite dans la Documentation SGI : sort() fournie, et déjà utilisée dans l'exo_04 du TP 4), puis afficher son contenu.

    Recopier le fichier Makefile_03 dans Makefile_04. Effectuer les ajouts nécessaires correspondant à la classe CCptIdent.

    Compiler et tester.

Corrigés : exo_04.cxx      -      Makefile_04      -      CCptIdent.h      -      CCptIdent.cxx      -      CCptIdent.hxx

Sommaire

Téléchargement des corrigés :

Chemins d'accès aux sources des corrigés :

© D. Mathieu     mathieu@romarin.univ-aix.fr
I.U.T.d'Aix en Provence - Département Informatique