Chapitres traités    Nombre "Complexe" Les énumérations La classe Diviseurs La classe Pôlynome

Dans l’ensemble de ce TP, vous allez tester le comportement de la redéfinition des opérateurs. Pour bien maîtriser ces concepts, il est impératif d’utiliser le « debugger » pour contrôler l’enchaînement des exécutions notamment lors de l’appel implicite des constructeurs. Pour cela, appuyer successivement sur la touche « F7 » (Mode pas à pas approfondi).

Nombre « Complexe »

Par rapport à l’écriture de base de la déclaration de la classe « Complexe », vous allez rajouter successivement un ensemble de fonctionnalités. A chacune de ces fonctionnalités, un scénario vous sera proposer afin de contrôler la nouvelle fonction (ou méthode). Ce test sera systématiquement évalué avec le « debugger » en mode pas à pas approfondi.

1. Votre premier test consiste à développer l’opérateur « + » en tant que méthode fonction membre) vu dans le cours et suivez le scénario proposé ci-contre.
   
   
2. Avant la dernière instruction (return), rajoutez la ligne suivante :
   
   c5 = 7.5+c2 ;
   
   Pourquoi la compilation ne s’effectue pas ?
   
   
3. Changer la méthode « + » pour qu’elle devienne une simple fonction amie de la classe « Complexe ». Effectuez le test avec la nouvelle instruction proposée en 2. (Toujours en utilisant le debugger et en contrôlant toutes les lignes puisque le code a changé).
   
   
4. Avant la dernière instruction, rajoutez la ligne suivante :
   
   double d = c2 ;
   
   Qu’effectue normalement cette ligne d’instruction ?
   Est-ce que la compilation s’effectue normalement ?
   Proposer la méthode nécessaire au bon déroulement du programme.
   Malgré cette nouvelle écriture, vous avez de nouvelles erreurs de compilation, notamment des problèmes d’ambiguïté. Pourquoi le compilateur se trouve dans une situation ambigüe ? Placez des commentaires sur les lignes de codes où vous avez une addition entre des réels et des nombres complexes. L’ambigüité est-elle toujours présente ?
   
   
5. Est-ce que l’instruction ci-dessous est correcte ? que se passe t-il réellement ?
   
   d = (c1 = c2).module() ;
   
   
   
6. Vous allez mettre en œuvre un certain nombre d’opérateurs dont la liste vous est communiquée ci après, ce qui permettra d’avoir une utilisation des nombres complexes naturelle. Tester ces nouveaux opérateurs en proposant des lignes de code adaptées. Les opérateurs à redéfinir : (-, *, /, +=, -=, *=, /=).
   
   
   Corrections : Commentaires sur les questions posées.
   .
   

Les énumérations

Les opérateurs peuvent être redéfinis pour tous les types créés par le programmeur. C’est évidemment le cas pour les classes, mais également pour tous les autres types définis par l’utilisateur. Nous avons déjà étudiés les énumérations en constatant que, par défaut, les incrémentations et les décrémentations ne sont pas pris en compte. Cet exercice consiste à palier ce problème. Nous aimerions pouvoir implémenter le scénario proposé ci-dessous. Il est à noter que, dans le cadre d’une énumération, il n’est pas possible d’utiliser des méthodes (fonctions membres à l’énumération).

Par ailleurs, il existe deux types d’incrémentation : la pré-incrémentation, et la post-incrémentation. Dans le premier cas, la signature de l’opération est classique (à vous de trouver). Dans le second, il est nécessaire d’utiliser une signature différente pour que le compilateur sache faire la différence, et dans ce cas, il a été prévu de rajouter un paramètre supplémentaire de type entier. Généralement ce paramètre supplémentaire ne sert à rien, on peut donc l’ignorer. Il faut, par contre, qu’il apparaisse pour que le compilateur sache faire la différence entre la pré et la post incrémentation.

La classe Diviseurs

Nous allons reprendre la classe Diviseurs qui représente l'ensemble des diviseurs d'un nombre entier naturel. Nous allons rajouter de nouvelles compétences afin que notre classe devienne de plus en plus performante, et surtout encore plus agréable à utiliser. Pour cela, vous allez redéfinir deux opérateurs qui permettront d'exploiter cette classe de façon plus conviviale, savoir :

1. operateur [ ] : Cet opérateur offre une deuxième alternative à la méthode getDiviseur(), et permet ainsi d'avoir une écriture plus concise.
2. operateur bool : Cet opérateur offre une deuxième alternative à la méthode premier(), et permet ainsi d'avoir une écriture plus concise.

Pour tester votre nouvelle classe, vous utiliserez le même programme que nous avions déjà mis en oeuvre dans le TP précédent.

Avec ci-dessous, le programme principal qui bénéficie de l'apport de ces nouveaux opérateurs :

La classe Polynome

Nous allons également changer le comportement de la classe Polynome qui, je le rappelle, représente, par exemple, le nombre suivant :

Nous allons, tout simplement rajouter quelques fonctionnement supplémentaires afin de permettre une meilleurs convivialité quant aux objets relatifs à cette classe. Pour cela, nous allons redéfinir un certain nombre d'opérateurs :

Tout d'abord, concernant la classe Rationnel, vous avez déjà défini une fonction addition qui permet d'effectuer l'addition de deux nombres rationnels. Il serait préférable d'utiliser l'opérateur + à la place de cette fonction addition.

Ensuite, comme cela vous est présenté dans le diagramme UML ci-dessus, vous allez redéfinir l'opérateur + ainsi que l'opérateur [ ]. Attention, ce dernier doit être privé. Il est seulement utilisé par les méthodes inernes. Dans ce cas précis, il est préférable d'imposer à l'utilisateur de la classe, les méthodes spécifiques setCoef et getCoef plutôt que l'opérateur [ ] par soucis de visibilité.

En tenant compte du diagramme de classe ci-dessus et du scénario proposé ci-dessous, construisez les classes Polynome et Rationnel.

#include "Polynome.h"
//------------------------------------------------------------------------------
int main()
{
  Polynome p(3);
  p.setCoef(0, 5);
  p.setCoef(1, Rationnel(3, 2));
  p.setCoef(2, Rationnel(7,4, Negatif));
  p.setCoef(3, 10);
  Polynome p1 = Rationnel(8, 5, Negatif);
  Rationnel r[] = { 8, Rationnel(5, 2, Negatif), 7, Rationnel(7, 1, Negatif)};
  Polynome p2(3, r);
  p.getCoef(1).setDenominateur(4);
  Polynome p3(3);
  p3 = p + p2;
  return 0;
}
//------------------------------------------------------------------------------

Utiliser le debugger pour bien tester le fonctionnement global. Vous en profiterez pour bien contrôler le cheminement des appels des méthodes respectives. Vous remarquerez que l'addition ne fonctionne pas très bien. Il est nécessaire de redéfinir complètement le comportement par défaut de la classe Polynôme puisqu'elle dispose d'objets internes dynamiques. Ce sujet sera traité dans la prochaine leçon.