Cours

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Partie I – Surcharge des compteurs ======

Nous repartons à partir du code des compteurs que nous avons effectué lors de la première séance. 

Vous pouvez téléchargé le contenu des fichiers 


  - [[in204:tds:sujets:td7:counter_hpp|Counter.hpp]],

vous permettant d’avoir accès au code qui correspondrait normalement à ce qui avait été réalisé à la fin de la seconde séance [[in204:tds:sujets:td2|TD2]].

Vous pouvez tout autant repartir de votre code si vous l’avez archivé.

===== Question n° 1 ======

Ajouter à la classe ''BaseCounter'' deux nouvelles méthodes virtuelles pures ''next()'', resp. ''next(unsigned)''. Ces deux méthodes purement virtuelles ont pour objet d’appeler les méthodes par défaut pour passer à la valeur suivante. 

Typiquement, pour un compteur qui compte, ce seront les méthodes ''increment()'' et ''increment(unsigned)''. Pour un compte qui décompte, ce seront les méthodes ''decrement()'' et ''decrement(unsigned)''.

===== Question n° 2 ======

Ajouter aux classes BaseCounter, ''ForwardCounter'' et ''BackwardCounter'', deux nouvelles méthodes ''next()'', resp. ''next(unsigned)''. Cette méthode ''next()'' (resp. ''next(unsigned)'') appellera la méthode ''increment()'', (resp. ''increment(unsigned)'') pour la classe ''ForwardCounter''. cette méthode ''next()'' (resp. ''next(unsigned)'') appellera la méthode ''decrement()'', resp. ''decrement(unsigned)'' pour la classe ''BackwardCounter''.

===== Question n° 3 ======

Ecrire une fonction qui prendre comme paramètre une référence à la classe ''BaseCounter'' et qui fait appel à la méthode ''next'' un certain nombre de fois. 

Tester cette fonction avec des objets instances de ''ForwardCounter'' et ''BackwardCounter'' dont le code ressemble à la fonction suivante.


<code>
testNext(BaseCounter& aCounter)
    for i = 1  to 10
        aCounter.next();
        aCounter.print();
    end
</code>
 
===== Question n° 4 ======

L’ancienne méthode ''print()'' est définie au niveau de la classe de base ''BaseCounter''. Nous souhaitons la redéfinir par une méthode virtuelle :

<code cpp>
    template<class charT, class traits> 
    void print(std::basic_ostream<charT, traits>& aStream)
    {
        aStream << "Counter" << counter << "/" << max << std::endl;
    }
</code>

Ajouter la surcharge de l'opérateur ''operator <<'' appelant la méthode ''print'' précédemment définie.

<code>
template<class charT, class traits> operator << (std::basic_ostream<charT, traits>& aStream, 
    const BaseCounter& aBaseCounter)
{
    aBaseCounter.print(aStream);
    return aStream;
}
</code>

Nous souhaitons que les classes dérivées modifient le comportement de la méthode ''print''. 
Par exemple pour ''ForwardCounter'', nous souhaitons avoir l’affichage suivant :

<code>
template<class charT, class traits> print(std::basic_ostream<charT, traits>&)
    affiche "ForwardCounter : " m_counter "/" m_max (retour à la ligne)
</code>

**ATTENTION** Il n'est pas possible de créer un patron de méthodes virtuelles. En fait, il faut modifier la méthode ''print'' de ''BaseCounter'' pourqu'elle récupère le nom de la classe effective, par exemple en appelant une méthode ''getClassName'' qui retourne le nom de la classe effective, soit ''BaseCounter'' pour la classe ''BaseCounter'', ''ForwardCounter'' pour la classe ''ForwardCounter'' et ainsi de suite.

Modifier en conséquence les classes ''BaseCounter'', ''ForwardCounter'', ''BackwardCounter'' et ''BidirectionalCounter''.

===== Question n° 5 ======

Nous souhaitions modifier le comportement des compteurs. 

Actuellement, lorsque la valeur du compteur de ForwardCounter atteint la valeur max, il recommence à compter à partir de la valeur minimale.

Nous aimerions pouvoir rendre ce comportement « adaptable », c’est-à-dire que nous ne souhaitons pas modifier les méthodes ''increment(…)'' mais simplement le comportement quand la valeur maximale est atteinte et ce pour toutes les méthodes ''increment(…)''.

Pour ce faire, nous suggérons de modifier la méthode ''increment()'' de la manière suivante :
  * ''m_counter'' est plus petit que ''m_max'' alors incrémente ''m_counter''.
  * ''m_counter'' est égal à ''m_max'' la méthode appelle une méthode virtuelle ''reachMaximum()'' qui décide ce qu’il faut faire lorsque la valeur maximale du compteur est atteinte.

Modifier ''ForwardCounter'' afin d’implanter le comportement précédemment décrit.

===== Question n° 6 ======

Dériver de la classe ''ForwardCounter'' une classe ''VerboseForwardCounter'' qui lorsque la valeur maximale affiche un message avant de remettre la valeur du compteur à 0.

Vérifier le bon comportement de ''VerboseForwardCounter'' avec une fonction de test de type :

<code cpp>
void testForwardCounter(const ForwardCounter& aCounter)
{
    for(int i = 0 ; i < 10 ; i++)
        aCounter.increment();
}
</code>
 
===== Question n° 7 ======

** A faire en dehors de la séance de TD **


Actuellement, lorsque la valeur du compteur de ''BackwardCounter'' atteint la valeur ''m_min'', il recommence à compter à partir de la valeur maximale.

Nous aimerions pouvoir rendre ce comportement « adaptable », c’est-à-dire que nous ne souhaitons pas modifier les méthodes ''decrement(…)'' mais simplement le comportement quand la valeur minimale est atteinte et ce pour toutes les méthodes ''decrement(…)''.

Pour ce faire, nous suggérons de modifier la méthode ''decrement()'' de la manière suivante :
  * ''m_counter'' est plus petit que ''m_max'' alors incrémente ''m_counter''.
  * ''m_counter'' est égal à ''m_max'' la méthode appelle une méthode virtuelle ''reachMinimum()'' qui décide ce qu’il faut faire lorsque la valeur maximale du compteur est atteinte.

Modifier ''BackwardCounter'' afin d’implanter le comportement précédemment décrit.

===== Question n° 8 ======

** A faire en dehors de la séance de TD **

Modifier la classe ''BidirectionnalCounter'' pour rendre son comportement « adaptable », c'est-à-dire que nous pouvons spécifier comment le compteur continue de compter lorsque la valeur maximale et la valeur minimale sont atteintes.

===== Question n° 9 ======

** A faire en dehors de la séance de TD **

Supprimmer tous les fonctions ''increment'' et ''decrement'' dans les classes ''BaseCounter'', ''ForwardCounter'', ''BackwardCounter'' et ''BidirectionnalCounter'' et remplacer les par les opérateurs ''operator ++()'', ''operator ++(int)'', ''operator += (unsigned)'' et si nécessaire les opérateurs ''operator --()'', ''operator --(int)'' et ''operator -=(unsigned)''.
Cours

User Tools

Site Tools

Page Tools
