===== Partie V – Destructeurs ===== 

[[in204:tds:sujets:td2|TD2]]


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

En partant du code des classes BaseCounter, ForwardCounter, BackwardCounter et BiDiCounter, ajouter à chacune de ses classes un destructeur qui affiche simplement le message « Destruction : » suivi du nom de la classe.

<hidden Correction>

Il suffit d'ajouter pour chacune des classes un destructeur du type :

<code cpp>
class ClassName
{
public:
    .... 
    ~ClassName()
    {
            std::cout << "Destruction: ClassName@" << this << std::endl
    }
};    
</code>

Ce qui nous donne les classes suivantes :

<code cpp>
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) {}

        ~ForwardCounter()
        {
            std::cout << "Destruction: ForwardCounter@" << this << std::endl
        }
};
 
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) {}

        ~BackwardCounter()
        {
            std::cout << "Destruction: BackwardCounter@" << this << std::endl
        }
};
 
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) {}
        
        ~BiDiCounter()
        {
            std::cout << "Destruction: BiDiCounter @" << this << std::endl
        }
};
</code>

</hidden>

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

Tester le fonctionnement du destructeur à partir de la fonction :

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

<hidden Commentaire>

En executant le code, vous pouvez déterminer dans quel ordre les destructeurs sont appelés pour les différents types de compteurs. En fait, les destructeurs sont appelés dans l'ordre inverse de l'appel des constructeurs. 

Pour un compteur de type ''ForwardCounter'', c'est le destructeur de l'extension ''ForwardCounter'' qui est d'abord appellé puis ensuite le destructeur de ''BaseCounter''. En effet, on détruit d'abord les extensions définies par ''ForwardCounter'' et ensuite la classe de base ''BaseCounter''.

</hidden>