Choisissez votre style : colorisé, impression

Série 19 :
Surcharge d'opérateurs.

Buts

Cette série a pour but de vous faire faire pratiquer la surcharge des opérateurs.
Notez qu'à partir de cette semaine, les séances de TP seront entièrement consacrée à la programmation du projet.
Le matériel donné dans les séries (et leurs corrigés) peut être étudié comme complément (et source d'inspiration pour le projet!).

Préliminaires :

Si vous souhaitez coder les exercices décrits dans cette série, créez le répertoire ~/Desktop/myfiles/Programmation/cpp/serie19 et travaillez dans ce répertoire pour les exercices ne faisant pas partie du projet.
Si vous n'avez pas le temps de faire la partie "exercices" de la série, veillez au moins à en consulter le corrigé. Ceci vous donnera de précieuses indications pour le codage de votre projet.

Mise en place sous QTCreator

Cette série peut être réalisée avec Geany ou QTCreator. Si vous souhaitez utiliser QTCreator, vous pouvez mettre en place le projet comme suit:

copiez l'archive fournie serie19.zip dans le répertoire cpp/serie19/

Dézippez cette archive :

cd
cd Desktop/myfiles/Programmation/cpp/serie19/
unzip serie19.zip
rm serie19.zip

Lancez le programme QTCreator, et ouvrez y le fichier fourni dans ce répertoire et nommé CMakeLists.txt. Procédez comme indiqué ici https://iccsv.epfl.ch/series-prog/install/installation-tutorial.php#qtcreator-cmakeproject depuis la section "Création du projet".
Vous pouvez choisir lequel des programmes vous voulez lancez en cliquant sur le petit écran (Debug) sur le bandeau latéral gauche.

Exercice 0 : un exemple pas à pas (Constructeurs et Surcharge d'opérateurs, niveau 0)

Pages 124 et suivantes de l'ouvrage C++ par la pratique.

Le but de cet exercice est de réaliser pas à pas un exemple illustrant les différents constructeurs, ainsi que quelques surcharges d'opérateurs.

Cliquez ici si vous souhaitez faire cet exercice.

Exercice 1 : encore un peu plus de polynômes (niveau 2)

Exercice n°54 (page 133 et 314) de l'ouvrage C++ par la pratique.

Le but de cet exercice est de faire de façon propre et complète une classe permettant la manipulation de polynômes (réels).

Pour ceux qui n'ont pas fait l'exercice 0 :

Définissez la classe Polynome comme un tableau dynamique de double (Par exemple 2.5 X⁴ + X + 9.2 sera stocké sous la forme du tableau de coefficients {9.2, 1.0, 0, 0, 2.5}).
Ajoutez y la méthode degre() qui donne le degré du polynôme. Définissez à cette occasion le type Degre utilisé pour représenter le degré d'un polynôme.
Ajoutez un constructeur par défaut qui crée le polynôme nul, un constructeur plongeant le corps des réels dans celui des polynômes (Polynome(double);) et un constructeur de copie.
Ajoutez aussi un constructeur permettant de construire facilement des monômes (a Xⁿ), en précisant le coefficient (a) et le degré (n) : Polynome(double a, Degre n)
Passez ensuite à l'opérateur (externe) << d'insertion dans un stream

Pour finir cette partie introductive, ajoutez les opérateurs de multiplication (par un polynôme et aussi par un réel).

Polynome operator*(const Polynome& q) const;
Polynome operator*(const double) const;
Polynome& operator*=(const Polynome& q);
Polynome& operator*=(const double);
friend Polynome operator*(const double, const Polynome&);

Si vous n'avez pas jugé utile de suivre l'exercice 0, jouez vraiment le jeu et essayez de faire par vous même cette partie.

Pour tout le monde :

Ajoutez les opérateurs pour l'addition et la soustraction.
Pour la soustraction, faire attention à ce que les polynômes restent toujours « bien formés », c'est-à-dire que le coefficient de plus haut degré soit non nul (sauf pour le polynôme nul).
Pensez donc à fournir une méthode simplifie() supprimant les coefficients nuls pour les plus hauts degrés : X² doit être stocké sous la forme {0.0, 1.0} et non pas {0.0, 1.0,0 ,0 } par exemple).
Ajoutez les opérateurs de comparaison == et != (deux polynômes sont égaux s'ils ont les mêmes vecteurs de coefficients).
Ajoutez une méthode top qui retourne la valeur du coefficient de plus haut degré du polynôme.
Ajoutez maintenant la méthode (publique) divise() qui implémente la division des polynômes telle que décrite par l'algorithme suivant :

Cet algorithme prend en entrée deux polynômes, un numérateur et un dénominateur et retourne deux autres polynômes, un quotient et un reste, avec : numérateur = dénominateur * quotient + reste.
Par exemple, la division de 5X³ + 4X² - 2X + 3 par -2X² + 2X + 1 retourne comme quotient -2.5X - 4.5 et comme reste 9.5X + 7.5.
Terminer en implémentant les opérateurs de division et modulo à l'aide de la méthode divise.

Projet : démarrage

Cette semaine, la partie du projet que vous devez commencer coder est celle décrite à l'étape 1 de l'énoncé.

Série 19 : Surcharge d'opérateurs.