Module de POO/C++ Master 1 Mathématiques

TP6

Ex1 : La classe Complex

On se propose de réaliser une classe Complex permettant de modéliser les nombres complexes mathématiques
que nous connaissons.

Pour ce faire, dans un fichier [Link], déclarer une classe Complex. Cette classe aura deux données
membres privées :

• _imag, de type double, pour la partie imaginaire.

Fonctions membres à déclarer :

• Un constructeur par défaut (sans argument) qui initialise à 0 les parties réelles et imaginaires.
• Un constructeur prenant deux « double » pour initialiser les parties réelles et imaginaires.
• Une surcharge de l’opérateur + permettant d’additionner deux nombres complexes.

De plus, il conviendra de déclarer une surcharge de l’opérateur << permettant un affichage avec cout d’un
objet de type Complex. Cette fonction sera déclarée amie de la classe.

Dans un fichier [Link], écrire le corps de ces fonctions.

Ecrire une fonction main dans un fichier [Link] permettant de tester le code.

POUR RAPPEL

Pour compiler un petit projet de C++, la méthode la plus simple est de compiler tous les fichiers cpp en même
temps. On écrira par exemple, sur la même ligne dans un terminal ou xterm :
g++ [Link] [Link]

IL NE FAUT PAS :

• Inclure de fichier .cpp comme si c’était un header. Cela rend impossible la compilation ci-dessus.
• Compiler des fichiers header .hh

Ex 2 : vector

La librairie STL, livrée nativement avec le compilateur C++, propose une implémentation optimisée et complète
de la classe vector que nous avons aperçue dans les TPs et le cours.

Pour pouvoir l’utiliser, il est nécessaire d’inclure le header <vector>.

Il s’agit d’une classe template c’est-à-dire qu’elle est écrite une fois pour toutes et peut être utilisée pour
n’importe quel type de données.

Si, par exemple, on veut stocker un certain nombre de double, on peut instancier la classe vector pour le type
double en écrivant :
vector<double> vect ; // Cette instruction déclare un objet vect qui est de
type vector de double.

ou
vector<double> vect(5) ; // pour créer un vector contenant déjà la place
pour 5 double.

La taille d’un vector est disponible grâce à la fonction membre size(). On pourra écrire par exemple
[Link]()

pour connaître le nombre d’éléments contenus dans vect.

On peut ajouter des éléments dans un vector :

L’opérateur [] a également été surchargé pour accéder ou modifier un élément du vecteur.

Pour cet exercice, nous allons nous familiariser avec la classe vector de la STL.

Dans un fichier [Link], écrire une fonction main qui réalisera les tâches suivantes :

Déclarer un vector de 5 Complex, appelé V. (utiliser la classe de l’exercice 1).

Déclarer deux nombres complexes c et c2 valant respectivement (2,3) et (3,4)

• V[0] doit valoir c

On peut afficher les éléments de V grâce à cout. Cela utilisera alors la surcharge de l’opérateur << que nous
avons réalisée lors du premier exercice.

On aimerait pouvoir écrire des instructions du type :

Réaliser la surcharge de l’opérateur << pour un vector. On pourra écrire cette surcharge dans le même fichier
[Link]. Il faudra faire attention que, comme la classe vector est une classe template, cette fonction devra
être une fonction template. On pourra aussi essayer de l’utiliser sur un vecteur de int (en utilisant la fonction
push_back de la classe vector. Le comportement devrait être complétement identique sans avoir à modifier le
code de l’opérateur.
Ex. 3 : Tri

Nous avons une classe Complex et un moyen de stocker un certain nombre d’éléments de Complex. Nous allons
maintenant essayer de trier ces nombres contenus dans le vecteur.

Pour cela, il est nécessaire d’avoir :

• Un critère de comparaison de deux Complex : nous allons nous baser sur le module de celui-ci.
• Un algorithme de tri : nous allons implémenter le tri à bulle.

Dans un fichier [Link], réaliser une fonction ’ tri ‘ implémentant l’algorithme dont le pseudo code se trouve
ci-dessous :

tri_à_bulles(Tableau T)
pour i allant de taille de T - 1 à 1
pour j allant de 0 à i - 1
si T[j+1] < T[j]
échanger(T[j+1], T[j])
(Source : Wikipédia)

Cette fonction prendra en argument une référence sur un vector. Cette fonction devra être template car vector
nécessite un type pour s’instancier.

On remarque la ligne
si T[j+1] < T[j]

Il faut que la comparaison existe pour le type de vector. C’est trivial s’il s’agit d’un type numérique comme un
double, un float ou un int, mais par pour les Complex.

Dans la classe complexe, il faut donc surcharger l’opérateur < qui dira que
a < b si module de a < module de b.

Dans la fonction main, utiliser tout ce qui a été fait jusqu’à présent pour trier un tableau de Complex.

On peut aussi utiliser l’algorithme de tri pour trier des chaînes de caractères :

Utiliser la classe string (include <string>) pour déclarer un vector de string. On pourra trier ce vector en utilisant
la même fonction de tri.
Ex. 4 : Héritage

Récupérer les fichiers suivants sur la page des corrections :

• [Link], [Link]
• [Link], [Link]

La classe Mat22 donne une implémentation d’une matrice 2x2. Point2D est une structure représentant un point
dans l’espace.

On commencera par étudier le code présent dans ces fichiers.

Ecrire deux nouveaux fichiers [Link] et [Link]. Dans [Link], on déclarera une classe Rot héritant publiquement
de la classe Mat22.

Cette classe n’aura pas de données membres. Elle aura les deux fonctions membres suivantes :

Un constructeur prenant un double en paramètre. Ce nombre représentera l’angle de rotation de la matrice.

Une surcharge de l’opérateur () prenant une référence constante sur Point2D et renvoyant un objet de type
Point2D. Cette fonction appliquera la rotation sur le point en paramètre et renverra un nouveau Point.

Dans une fonction main, déclarer une variable r de type Rot avec un angle de Pi / 4. On pourra définir la constante
Pi en copiant/ collant la ligne ci-dessous dans [Link] (en dehors de la fonction main) :
const double PI =3.141592653589793238463;

On déclarera aussi un Point2D ayant comme coordonnées (1, 0).

Après une double rotation de Pi / 4, on devrait trouver (0, 1) (aux erreurs d’approximation prés.)

Pour rappel, les matrices de rotations dans le plan sont des matrices de la forme (pour une rotation d’angle 𝜃 ):
cos 𝜃 −𝑠𝑖𝑛𝜃
𝑅(𝜃) = ( )
𝑠𝑖𝑛𝜃 𝑐𝑜𝑠𝜃
On pourra ainsi utiliser les opérateurs [] et << présents dans la classe parente Mat22 avec les matrices de rotation
Rot.