0
PROSIT 4
[Racim LONGOU]
Rôle Nom Prénom
Animateur NIATI Mohammed
Scribe Youcef DJARIR
Gestionnaire abdelrahmen
Secrétaire Nazim
19/05/2025 A2 – Groupe
G2
1. Mots clés :
Parcoure de point.
Partie redondante.
Programme.
2. Mots à définir :
Distance euclidienne : La distance euclidienne est une mesure de la distance "à vol
d'oiseau" entre deux points dans un espace euclidien (comme une ligne, un plan ou un
espace tridimensionnel). Elle est calculée comme la racine carrée de la somme des
carrés des différences entre les coordonnées correspondantes des deux points.
3. Analyse du contexte :
Le programme calcule des distances euclidiennes entre points et gère des parcours 2D/3D, mais
souffre de redondances et de difficultés pour convertir un point 3D en point 2D.
4. Définition de la problématique :
Comment régler le problèmes de redondance et transformer un point 3d au 2d ?
5. Les contraintes :
Main
Classes
6. Plan d’actions :
1. [Faire des recherches su le polymorphisme] :
a. Qualification : abouti
b. Démonstration :
Le polymorphisme est un concept clé en programmation orientée objet (POO), qui permet à des
objets de différents types de se comporter de manière uniforme tout en ayant des comportements
spécifiques. En C++, le polymorphisme se manifeste principalement sous deux formes :
polymorphisme à la compilation et polymorphisme à l'exécution.
1. Polymorphisme à la compilation (ou statique)
Le polymorphisme à la compilation se produit lorsque le comportement est déterminé à la
compilation, par exemple, grâce aux surcharges de fonctions ou aux modifications de l'opérateur.
Ce type de polymorphisme ne nécessite pas l'utilisation de l'héritage.
Surcharge de fonctions : Plusieurs fonctions peuvent avoir le même nom mais avec des
signatures différentes (nombre ou type de paramètres).
Surcharge d'opérateurs : Il est possible de redéfinir les opérateurs (comme +, -, etc.) pour
des types personnalisés.
2. Polymorphisme à l'exécution (ou dynamique)
Le polymorphisme à l'exécution se base sur l'héritage et les méthodes virtuelles. C’est ce type de
polymorphisme qui permet à une fonction de se comporter différemment selon le type de l’objet
auquel elle s'applique, même lorsque le type est déterminé à l'exécution.
Méthodes virtuelles : Une méthode virtuelle permet à la classe dérivée de
redéfinir une méthode définie dans la classe de base.
Utilisation du mot-clé virtual et override :
o Le mot-clé virtual dans la classe de base permet de déclarer une méthode comme virtuelle.
o Le mot-clé override dans la classe dérivée indique que la méthode redéfinit une méthode de
la classe de base.
Avantages du polymorphisme
Réutilisation du code : Le polymorphisme permet de traiter des objets de différentes classes de
manière uniforme tout en maintenant leurs comportements spécifiques.
Extensibilité : Il est facile d'ajouter de nouvelles classes sans modifier le code existant, ce qui
améliore la maintenance du code.
Flexibilité : Le polymorphisme permet de définir des fonctions génériques qui agissent sur des objets
de types variés.
2. [Diagramme de classe a partie du main fournis ] :
a. Qualification : abouti
b. Démonstration :
3 [Link]
3. [implementer le code en utilisant des class (héritage et polymorphisme ] :
c. Qualification : abouti
d. Démonstration :
4 [Link]
Nous commençons par définir une classe abstraite Point. Cette classe sert de base commune pour
tous les types de points (2D ou 3D). Elle contient deux méthodes virtuelles pures : afficherCoordo
pour afficher les coordonnées d'un point, et distance, qui calcule la distance entre ce point et un
autre. Ces méthodes sont marquées comme virtual et = 0, ce qui signifie que toute classe dérivée
devra les implémenter.
Ensuite, la classe Point2D représente un point dans un espace à deux dimensions. Elle hérite de la
classe Point et implémente ses méthodes virtuelles. Les coordonnées x et y sont stockées sous
forme de membres privés. La méthode distance utilise une autre instance de Point2D, que nous
convertissons dynamiquement à l'aide de dynamic_cast. Si la conversion réussit, nous utilisons la
formule de la distance euclidienne pour calculer la distance entre les deux points. La méthode
afficherCoordo affiche les coordonnées du point au format (x, y).
De manière similaire, la classe Point3D représente un point dans un espace à trois dimensions. Elle
ajoute une coordonnée z en plus de x et y. Sa méthode distance calcule la distance euclidienne en
prenant en compte les trois dimensions (x, y, z). La méthode afficherCoordo affiche les coordonnées
sous la forme (x, y, z).
Pour gérer des collections de points, nous définissons une classe abstraite Parcours. Cette classe est
conçue pour stocker une liste de points (quelle que soit leur dimension) et effectuer des opérations
sur ces points. Elle contient un vecteur points de type shared_ptr<Point>, ce qui permet de gérer les
instances dynamiques des points de manière efficace et sécurisée. Deux méthodes virtuelles pures
sont définies : calculDistance, qui calcule la distance totale entre les points du parcours, et message, qui
affiche des informations spécifiques au type de parcours.
Deux classes concrètes dérivent de Parcours : Parcours2D et Parcours3D. La classe Parcours2D est utilisée
pour des parcours de points 2D, tandis que Parcours3D gère des parcours de points 3D. Les deux
classes implémentent la méthode calculDistance de manière similaire : elles parcourent le vecteur
points et calculent la somme des distances entre chaque point consécutif. La méthode message
affiche un message indiquant si le parcours est de type 2D ou 3D.
Enfin, dans la fonction main, nous utilisons ces classes pour créer des points et des parcours. Dans
un premier temps, nous créons trois points 2D avec des coordonnées spécifiques. Ces points sont
ensuite ajoutés à un objet de type Parcours2D, et nous calculons la distance totale entre eux. Un
message indiquant le type de parcours est également affiché. Le même processus est répété pour
des points 3D et un objet de type Parcours3D.
Le programme utilise des techniques modernes de gestion de mémoire, notamment les pointeurs
intelligents (shared_ptr et unique_ptr), pour garantir qu'aucune mémoire n'est fuitée. Ces pointeurs
gèrent automatiquement la durée de vie des objets alloués dynamiquement, ce qui simplifie la
gestion mémoire.
En résumé, ce code utilise les principes de l'héritage et du polymorphisme pour permettre une
gestion flexible et extensible des points et des parcours. Chaque type de point ou de parcours est
implémenté comme une sous-classe spécifique, mais grâce au polymorphisme, le code peut les
traiter de manière uniforme, ce qui réduit la duplication de code et améliore la lisibilité.
5 [Link]
#include <iostream>
#include <cmath>
#include <vector>
#include <memory> // Pour std::shared_ptr
using namespace std;
// Classe de base pour un Point
class Point {
public:
virtual void afficherCoordo() const = 0;
virtual double distance(const Point* autre) const = 0;
virtual ~Point() {}
};
// Classe pour un Point 2D
class Point2D : public Point {
private:
double x, y;
public:
Point2D(double x, double y) : x(x), y(y) {}
double distance(const Point* autre) const override {
const Point2D* p = dynamic_cast<const Point2D*>(autre);
if (p)
return sqrt(pow(x - p->x, 2) + pow(y - p->y, 2));
return 0.0; // Cas où le type ne correspond pas
}
void afficherCoordo() const override {
cout << "(" << x << ", " << y << ")";
}
};
// Classe pour un Point 3D
class Point3D : public Point {
private:
double x, y, z;
public:
Point3D(double x, double y, double z) : x(x), y(y), z(z) {}
double distance(const Point* autre) const override {
const Point3D* p = dynamic_cast<const Point3D*>(autre);
if (p)
6 [Link]
return sqrt(pow(x - p->x, 2) + pow(y - p->y, 2) + pow(z - p->z, 2));
return 0.0; // Cas où le type ne correspond pas
}
void afficherCoordo() const override {
cout << "(" << x << ", " << y << ", " << z << ")";
}
};
// Classe de base pour les Parcours
class Parcours {
protected:
vector<shared_ptr<Point>> points;
public:
virtual void ajouterPoint(shared_ptr<Point> point) {
points.push_back(point);
}
virtual double calculDistance() const = 0;
virtual void message() const = 0;
virtual ~Parcours() {}
};
// Parcours 2D
class Parcours2D : public Parcours {
public:
double calculDistance() const override {
double totalDistance = 0.0;
for (size_t i = 1; i < [Link](); ++i) {
totalDistance += points[i - 1]->distance(points[i].get());
}
return totalDistance;
}
void message() const override {
cout << "Calcul d'un parcours de type 2D" << endl;
}
};
// Parcours 3D
class Parcours3D : public Parcours {
public:
double calculDistance() const override {
double totalDistance = 0.0;
for (size_t i = 1; i < [Link](); ++i) {
7 [Link]
totalDistance += points[i - 1]->distance(points[i].get());
}
return totalDistance;
}
void message() const override {
cout << "Calcul d'un parcours de type 3D" << endl;
}
};
// Fonction main
int main() {
shared_ptr<Point> p1 = make_shared<Point2D>(0.0, 0.0);
shared_ptr<Point> p2 = make_shared<Point2D>(1.0, 1.0);
shared_ptr<Point> p3 = make_shared<Point2D>(2.0, 2.0);
unique_ptr<Parcours> parcours = make_unique<Parcours2D>();
parcours->ajouterPoint(p1);
parcours->ajouterPoint(p2);
parcours->ajouterPoint(p3);
cout << parcours->calculDistance() << endl;
parcours->message();
p1 = make_shared<Point3D>(0.0, 0.0, 0.0);
p2 = make_shared<Point3D>(1.0, 1.0, 1.0);
p3 = make_shared<Point3D>(2.0, 2.0, 2.2);
parcours = make_unique<Parcours3D>();
parcours->ajouterPoint(p1);
parcours->ajouterPoint(p2);
parcours->ajouterPoint(p3);
cout << parcours->calculDistance() << endl;
parcours->message();
return 0;
}
7. Validation des hypothèses :
8 [Link]
1. [utiliser des méthodes virtuel pure ] :
a. Qualification : Faux
b. Démonstration :
Au Final, nous n’avons pas eu recours à l’utilisation des méthodes virtuelles pures dans notre
code
9 [Link]
