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 II – Constructeurs en C++ =====

[[in204:tds:sujets:td1|TD1]]

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

Nous considérons les deux fonctions suivantes (C++):

<code cpp>

void myfunctionA()
{
  MyCounter counter;
  std::cout << counter.getCounter() << std::endl;
  std::cout << counter.getMax() << std::endl;
}

void myfunctionB() 
{
  MyCounter* counter = new MyCounter();
  std::cout << counter->getCounter() << std::endl;
  std::cout << counter->getMax() << std::endl;
  delete counter;
}

</code>


Exécuter les deux fonctions et expliquer pourquoi la valeur des champs est différente dans le cas où les objets sont alloués sur la pile ou dans le cas où sont alloués sur le tas.

<hidden Correction>

Dans la fonction ''myfunctionA()'' l'objet est alloué sur la pile. Dans le cas d'une allocation sur la pile, la mémoire est obtenue en simplement retournant l'addresse mémoire courante du pointeur de pile et en incrémentant ensuite ce pointeur de la taille de l'objet.

<code> 
    @MyCounter <= StackPointer
    StackPointer <= StackPointer + sizeof(MyCounter);
</code>

Dans la fonction ''myfunctionB()'' l'objet est alloué sur le tats. Dans le cas d'une allocation sur le tas, la mémoire est obtenue par un appel à une fonction d'allocation comme par exemple ''malloc'' qui repose sur un à une fonction offerte par le système d'exploitation.


<code> 
    @MyCounter <= malloc(sizeof(MyCounter));
</code>

Même si a priori la documentation de ''malloc'' n'impose pas que la mémoire soit mise à zéro, la plupart des fonctions d'allocation de mémoire des systèmes d'exploitation mettent la mémoire à zéro pour éviter des problèmes de sécurité (ie. que l'on puisse retrouver des données manipulées par un autre programme et/ou un autre utilisateur et qui pourraient être confidentielles).

Dans le premier cas, nous comprenons que la valeur des champs ''count'' et ''max'' correspond aux valeurs présentes dans la pile. Dans le second cas, les valeurs des champs ''count'' et ''max'' sont a priori à zéro.

Il faut bien comprendre que si nous n'intialisons pas les champs de manière explicie, ceux-ci prendront la valeur contenue dans la mémoire, ce qui n'est que rarement ce que l'on souhaite.

Au final une bonne règle consiste systématiquement d'initialiser l'ensemble des champs définis dans un objet au moment de sa création.

</hidden>



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

Que faut-il ajouter à la classe pour garantir que le comportement soit toujours correct ?

<hidden Correction>

Il est nécessaire d'ajouter un constructeur par défaut qui initialise les champs de l'objet avec la valeur par défaut, soit ''0'' dans notre cas.

<code cpp>

struct MyCounter
{
    public: 
       MyCounter(): counter(0), max(0)
       {}
};
</code>
  
</hidden>
==== Question n° 3 ==== 

Dans la fonction ''useObjectA()'', le programme initialise les différents champs 
des compteurs. Ceci n’est pas très élégant.

Proposer une solution pour créer des compteurs en passant en paramètre le nombre 
maximal d’éléments comptés à partir duquel le compteur revient à 0.

Simplifier le code de la fonction ''useObjectA()'' une fois que vous avez 
proposé ces solutions.

<hidden Correction>

Il est possible d'ajouter des constructeurs spécialisés à la classe ''MyCounter'', nous proposons les deux constructeurs suivants :

<code cpp>
struct MyCounter
{
...
    explicit MyCounter(uint theMaxValue):
        counter(0), max(theMaxValue) 
    {}
    MyCounter(uint theCounter, uint theMaxValue): 
        counter(theCounter), max(theMaxValue)
    {}
};
</code>

Depuis la version C++11, il est possible de faire appel à un constructeur déjà défini. Ainsi, le code peut se simplifier comme suit :

<code cpp>
struct MyCounter
{
...
    explicit MyCounter(uint theMaxValue): 
        MyCounter((uint)0, theMaxValue)
        // Effectue un appel au constructeur MyCounter(uint, uint)
    {}
    MyCounter(uint theCounter, uint theMaxValue): 
        counter(theCounter), max(theMaxValue)
    {}
};
</code>

La fonction ''useObjectA()'' peut désormais s'écrire comme suit:

<code cpp>
void useObjectA() {
    MyCounter Counter1(2);
    MyCounter Counter2(4)
    for(unsigned i = 0; i <= 5; i++) {
      std::cout 
	<< "Valeur des compteurs (" 	<< Counter1.counter 
	<< ", " << Counter2.counter 	<< ")" << std::endl;
        Counter1.increment();
        Counter2.increment();
    }
}
</code>
</hidden>
==== Question n° 4 ====

Proposer enfin un constructeur de recopie qui permet de créer un nouveau compteur étant la copie d’un compteur passé en paramètre.
Cours

User Tools

Site Tools

Page Tools
