Cours

Le code consolidé de la classe MyBiDiCounter est le suivant:

class MyBiDiCounter: public MyCounter
{
public:
    MyBiDiCounter(): MyCounter() {}
    MyBiDiCounter(const MyBiDiCounter& anotherCounter):
        MyCounter(anotherCounter) {}
    explicit MyBiDiCounter(uint theMaxValue): MyCounter(theMaxValue) {}
    MyBiDiCounter(uint theCounterValue, uint theMaxValue): 
        MyCounter(theCounterValue, theMaxValue) {}
 
    void decrement() 
    {
        if(counter > 0) 
            counter --;
        else
            counter = max;
    }
 
    void print() const
    {
        std::cout << "Compteur: " << counter << "/" << max << std::endl;
    }
};

Ceci permet de simplifier le code de la fonction testMyBiDiCounter en supprimant les appels aux fonctions setMax et reset.

void testMyBiDiCounter()
{
    MyBiDiCounter counterA(4);
    counterA.print();
    for(int i=0; i < 6; i++)
    {
        counterA.increment();
        counterA.print();
    }
    for(int i=0; i < 6; i++)
    {
        counterA.decrement();
        counterA.print();
    }
}

L'ensemble des méthodes de MyCounter doivent être présentes dans la classes BaseCounter à l'exception de la méthode increment.

En effet, ces méthodes sont communes aux trois classes ForwardCounter, ReverseCounter et BiDiCounter.

Une proposition pour la classes BaseCounter serait la classe suivante :

#ifndef COUNTER_HPP
#define COUNTER_HPP
 
#include<iostream>
 
class BaseCounter
{
protected:
    unsigned counter;
    unsigned max;
 
public:
    unsigned getCounter() const { return counter; }
    unsigned getMax() const { return max; }
    void reset() { counter = 0; }
    void set(unsigned value) { counter = value; }
    void setMax(unsigned value)
    {
        max = value;
        if(value > counter)
            counter = counter % max;
    }
 
protected:
    BaseCounter(): counter(0), max(0) {}
    BaseCounterunsigned theCounter,
        unsigned theMax): counter(theCounter), max(theMax)
    {}
    BaseCounterunsigned (const BaseCounterunsigned & anotherCounter):
        counter(anotherCounter.counter),
        max(anotherCounter.max)
    {}
    ~BaseCounterunsigned ()
    {}
};

Nous supposons que la classe BaseCounter n'est qu'une pure classe de base, c'est-à-dire qu'aucun objet de type BaseCounter sera créé. Pour éviter de pouvoir créer un objet de type BaseCounter, nous modifions la visibilité des constructeurs de constructeurs public en constructeur protected. Désormais, les constructeurs ne pourront être appelés que par des classes qui dérivent de la classe BaseCounter, interdisant ainsi la possibilité de créer accidentellement un objet de type BaseCounter.

Cette correction propose de créer trois classes ForwardCounter, BackwardCounter et BiDiCounter qui héritent de la classe BaseCounter en l'étendant avec les fonctions manquantes :

• increment pour la classe ForwardCounter,
• decrement pour la classe BackwardCounter,
• increment et decrement pour la classe BiDiCounter.

Le code correspondant à cette solution est le suivant :

class ForwardCounter: public BaseCounter
{
    public:
        void increment()
        {
            if(counter < max)
                counter = counter + 1;
            else
                counter = 0;
        }
 
        ForwardCounter(): BaseCounter() {}
        ForwardCounter(const ForwardCounter& aCounter): BaseCounter(aCounter) {}
        explicit ForwardCounter(unsigned theMaxValue): ForwardCounter(0, theMaxValue) {}
        ForwardCounter(unsigned theCounter, unsigned theMaxValue): BaseCounter(theCounter, theMaxValue) {}
};
 
class BackwardCounter: public BaseCounter
{
    public:
        void decrement()
        {
            if(counter > 0)
                counter = counter -1;
            else
                counter = max;
        }
        BackwardCounter(): BaseCounter() {}
        BackwardCounter(const BackwardCounter& aCounter): BaseCounter(aCounter) {}
        explicit BackwardCounter(unsigned theMaxValue): BackwardCounter(0, theMaxValue) {}
        BackwardCounter(unsigned theCounter, unsigned theMaxValue): BaseCounter(theCounter, theMaxValue) {}
};
 
class BiDiCounter: public BaseCounter
{
    public:
        void increment()
        {
            if(counter < max)
                counter = counter + 1;
            else
                counter = 0;
        }
        void decrement()
        {
            if(counter > 0)
                counter = counter -1;
            else
                counter = max;
        }
 
        BiDiCounter(): BaseCounter() {}
        BiDiCounter(const BiDiCounter& aCounter): BaseCounter(aCounter) {}
        explicit BiDiCounter(unsigned theMaxValue): ForwardCounter(0, theMaxValue) {}
        BiDiCounter(unsigned theCounter, unsigned theMaxValue): BaseCounter(theCounter, theMaxValue) {}
};

Dans l'exemple précédent, nous constatons que nous définissons deux fois le code pour la fonction increment et la fonction decrement, ce qui conduit à dupliquer le code et surtout à devoir si jamais nous trouvons une erreur dans une des fonctions membres increment (resp. decrement) de devoir penser à corriger la deuxième implantation de la fonction membre increment (resp. decrement).

Dans ce cas, il est possible d'implanter les deux fonctions increment et decrement qui sont des fonctions internes à la classe et accessibles uniquement des classes dérivées. Ces fonctions contiennent le code de increment et de decrement, nous les avons préfixés par pour bien indiquer qu'il s'agit de fonction interne. Elles seront donc déclarées comme protected dans la classe BaseCounter qui désormais s'écrira comme suit : <code cpp> class BaseCounter { protected: unsigned counter; unsigned max; public: unsigned getCounter() const { return counter; } unsigned getMax() const { return max; } void reset() { counter = 0; } void set(unsigned value) { counter = value; } void setMax(unsigned value) { max = value; if(value > counter) counter = counter % max; } protected: BaseCounter(): counter(0), max(0) {} BaseCounterunsigned theCounter, unsigned theMax): counter(theCounter), max(theMax) {} BaseCounter (const BaseCounterunsigned & anotherCounter): counter(anotherCounter.counter), max(anotherCounter.max) {} ~BaseCounterunsigned () {} void increment() { if(counter < max) counter = counter + 1; else counter = 0; } void decrement() { if(counter > 0) counter = counter -1; else counter = max; } }; </code> Il suffit désormais d'ajouter aux classes ForwardCounter et BiDiCounter la fonction : <code cpp> public: void increment() { increment(); } </code> ainsi qu'aux classes BackwardCounter et BiDiCounter la fonction :: <code cpp> public: void decrement() { decrement(); } </code> Ce qui nous donne le code suivant pour les trois classes dérivées : <code cpp> class ForwardCounter: public BaseCounter { public: void increment() { increment(); } ForwardCounter(): BaseCounter() {} ForwardCounter(const ForwardCounter& aCounter): BaseCounter(aCounter) {} explicit ForwardCounter(unsigned theMaxValue): ForwardCounter(0, theMaxValue) {} ForwardCounter(unsigned theCounter, unsigned theMaxValue): BaseCounter(theCounter, theMaxValue) {} }; class BackwardCounter: public BaseCounter { public: void decrement() { decrement(); } BackwardCounter(): BaseCounter() {} BackwardCounter(const BackwardCounter& aCounter): BaseCounter(aCounter) {} explicit BackwardCounter(unsigned theMaxValue): BackwardCounter(0, theMaxValue) {} BackwardCounter(unsigned theCounter, unsigned theMaxValue): BaseCounter(theCounter, theMaxValue) {} }; class BiDiCounter: public BaseCounter { public: void increment() { increment(); } void decrement() { decrement(); } BiDiCounter(): BaseCounter() {} BiDiCounter(const BiDiCounter& aCounter): BaseCounter(aCounter) {} explicit BiDiCounter(unsigned theMaxValue): ForwardCounter(0, theMaxValue) {} BiDiCounter(unsigned theCounter, unsigned theMaxValue): BaseCounter(theCounter, theMaxValue) {} }; </code> </hidden> === Question n°3 === Tester le comportement de vos compteurs à partir du code suivant <code cpp> void testFamilyOfCounters() { ForwardCounter incCounter(0, 4); BackwardCounter decCounter(0, 3); BiDiCounter biDiCounter(0, 5); for(int i=0; i < 6; i++) { incCounter.increment(); incCounter.print(); decCounter.decrement(); decCounter.print(); biDiCounter.increment(); biDiCounter.print(); } for(int i=0; i < 6; i++) { biDiCounter.decrement(); biDiCounter.print(); } } </code>