Table of Contents

Partie V – Destructeurs

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.

Correction

Correction

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

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

Ce qui nous donne les classes suivantes : 

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

Question n°2

Tester le fonctionnement du destructeur à partir de la fonction : 

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

Commentaire

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.