Table des matières

1. Dérivation² (Dérivation de classes pour la dérivation d'expressions)

• Le but de cet exercice est de réaliser une application permettant de calculer la forme dérivée d'une expression arithmétique simple.

1.1. Conception et itération 1 (0,5 point)

Une expression est constituée de nombres ayant une valeur mémorisée par un flottant (classe Nombre), de variables ayant un nom (classe Variable) et des opérations arithmétiques + et * (classes Addition, Multiplication) (les classes Soustraction et Division sont laissées de côté pour ne pas compliquer inutilement l'exercice).

• Définir (diagramme de classes UML) l'arbre d'héritage permettant de manipuler de manière générale de telles expressions.
  
• Quel est l'intérêt d'avoir une super-classe Operation ?
  
  

• Commencer par définir en C++ les classes Expression, Nombre et Variable avec leurs attributs, constructeurs, destructeurs et comportements de copie.
  
  

• Écrire dans le ficher de test une fonction recevant une expression (qui sera en réalité un nombre, une variable…) et le résultat attendu de son affichage (sous forme de chaîne de caractères), et qui vérifie avec un test Google que l'affichage obtenu de l'expression (selon le protocole de la bibliothèque standard d'entrée/sortie de C++) est celui attendu.
  
  
• Écrire deux tests unitaires pour l'affichage d'un nombre et d'une variable ; ces deux tests feront appel à la fonction précédente.
  
  
• Constatez qu'une erreur de compilation est produite.
  
  
• Concevoir une solution pour éliminer cette erreur et obtenir le comportement souhaité.
  
  
• L'implémenter pour les classes Expression, Nombre et Variable.
  
  

#include <iostream>
#include <ios>

int main()
{
    double d{};
    std::cin >> d;
    // Supposons que l'utilisateur a donné 123.456789
    std::cout << "d = " << std::scientific << d << "\n";
    // L'affichage sera alors d = 1.234568e+02
}

• Nous souhaitons ajouter un comportement de dérivation d'une expression par rapport à une variable (la méthode recevra le nom de la variable en argument) : ce comportement peut soit modifier l'instance courante, soit créer une nouvelle instance représentant la dérivée de l'objet courant. Quelle est la bonne approche à retenir ici ?
  
  
• Spécifier aussi précisément que possible, sous forme de commentaire dans le fichier d'entête, le comportement de dérivation d'une expression (argument, type de retour, effet sur l'objet récepteur, type d'allocation si nécessaire).
  
  
• Écrire les tests unitaires pour la dérivation d'un nombre et d'une variable ; ces tests feront appel à la fonction de vérification par affichage déjà définie.
  
  
• Définir le comportement de dérivation pour les classes Expression, Nombre et Variable.
  
  
• Vérifier que les tests unitaires réussissent.
  
  

• Ajouter un mécanisme permettant de compter le nombre d'instances créées, celui d'instances détruites ; afficher ces nombres à la fin de main().
  
  

1.2. Itération 2 (1 point)

• Définir la classe Operation :
  • déterminer comment représenter en C++ les liens entre un opérateur et ses opérandes ;
  • le constructeur recevra les deux opérandes, définir sa signature ;
  • une opération doit-elle s'approprier les arguments reçus ou en faire une copie ?
  • que peut-on dire du mode d'allocation mémoire des opérandes reçus ?
  • quelle solution pour le constructeur de copie ?
  • définir la méthode justifiant l'existance de la classe Operation ; choisir comment les sous-classes pourront ajouter leur comportement spécifique ;
  • indiquer dans un commentaire les choix effectués ;
  • définir les méthodes de la classe Operation.
    

• Définir un test unitaire pour l'affichage d'une addition ; ajouter la classe Addition avec ses comportements nécessaires pour que le test réussisse.
• Définir un test unitaire pour la dérivation d'une addition ; modifier la classe Addition pour que le test réussisse.

• Appliquer la même démarche pour la classe Multiplication ; montrer la nécessité d'un comportement de clonage.
  
  

1.4. Simplification (1 point)

• Simplification des expressions :
  • identifier les possibilités de simplification des expressions ;
  • spécifier (la spécification complète doit figurer en commentaire) et déclarer la méthode

correspondante dans la classe Expression ;

• pour chaque classe concrète et de manière incrémentale :
  • écrivez un test unitaire correspondant à un cas de simplification possible pour cette classe ;
  • vérifier l'échec du test.
  • ajouter ce cas à la méthode de simplification ;
  • vérifier la réussite du test.

2. Partie avancée (1,5 point)

• Utiliser les pointeurs intelligents pour éviter le clonage.
  

• Éliminer les créations des nombres 0 et 1 lors des dérivations des nombres et des variables.
  

• Pourquoi est-il nécessaire de continuer à créer des instances dans Nombre::simplifie() et Variable::simplifie() ? Proposer une solution pour remédier à ce point.
  

• Comparer, sur une expression un peu compliquée, le nombre d'instances créées lors de la dérivation et de la simplification entre cette version et la version sans pointeurs intelligents.