Le document traite de la génération de code à partir de modèles UML et de la rétro-ingénierie de code C++, expliquant comment les diagrammes de classes UML se traduisent en code C++. Il décrit les concepts de classes, attributs, méthodes, héritage et associations en C++, avec des exemples illustrant la syntaxe C++. Enfin, il présente des exercices pratiques sur l'ingénierie à l'avant et à l'arrière pour renforcer la compréhension des concepts abordés.

1. L2ARS/SIL – 2011/2012
AGL – Chapitre 6
D’UML VERS C++
Mme. Lilia SFAXI
Mme. Abir Gallas

2. Génération de Code
 Génération: Production automatique
d’artéfacts à partir d’un modèle
 Exemple: à partir d’un diagramme de classes,
on peut générer:
Du code pour les classes du diagramme
Un document qui décrit les classes
textuellement
Un rapport représentant des faits sur le modèle

3. Rétro-Ingénierie
 Le contraire de la génération
 Analyse du code d’un programme pour
produire des modèles qui représentent la
même information de manière visuelle
 Exemple: faire de la rétro-ingénierie de
classes C++ résulte en un diagramme de
classes représentant les relations entre
elles.

4. Traduction UML-C++
 Diagramme de classes UML
Définit les composantes du système final
Ne définit pas le nombre et l’état des instances
individuelles
 Un diagramme de classes proprement réalisé
permet de:
Structurer le travail de développement de manière
efficace
Séparer les composantes pour répartir le
développement entre les membres d’un groupe
Construire le système de manière correcte

5. D’UML vers C++ :
Vocabulaire
 Le tableau suivant liste la conversion entre
les éléments du modèle UML vers du
code C++
Élément UML Élément C++
Packetage Répertoire / Namespace
Classe Classe (fichiers .h et .cpp)
Relation de Généralisation Héritage
Relation d’association/
agrégation/composition
Attribut
Attribut Attribut
Méthode Opération
Paramètre Argument d’Opération

6. Classes, Attributs et
Méthodes
 Représentation d’une classe, avec des attributs et méthodes
publics et privés.
Point
- abscisse_: entier
- ordonnée_: entier
+ x() : entier
+ y() : entier
+ deplacerDe(incX: entier,
incY : entier)
+ deplacerVers(dX: entier, dY
: entier)
class Point{
public:
Point( int abs, int ord)
int x(void) const;
int y(void) const;
void deplacerDe (int incX,
int incY);
void deplacerVers (int dX,
int dY);
private:
int abscisse_;
int ordonnee_;
};

7. Attributs et Méthodes
« de Classe »
 Attribut/Méthode de classe:
 Commun à tous les objets créés
 Exemple: compteur du nombre d’instances créées.
Point
…
+ NbPoints_: entier
…
+ NbPoints() : entier
class Point{
public:
static int NbPoints(void);
private:
static int NbPoints_;
};

8. Classes et Méthodes
Abstraites
 Méthode Abstraite
Méthode déclarée sans d’implémentation
 Classe Abstraite
Classe contenant au moins une méthode abstraite
ObjetGraphique
…
…
+ afficher()
class ObjetGraphique{
public:
virtual void afficher(void) = 0;
…
};

9. Héritage
ObjetGraphique
# pointBase_:Point
# couleur_: entier
# epaisseur_: entier
« constructor» +ObjetGraphique
+ afficher()
Cercle
# rayon_:entier
« constructor» + Cercle
+ afficher()
class ObjetGraphique {
public:
ObjetGraphique (int x, int y, int
couleur=0, int epaisseur=0)
: pointBase_(x,y),
couleur_(couleur),
epaisseur_(epaisseur) {}
protected:
Point pointBase_;
int couleur_;
int epaisseur_;
};
class Cercle : public ObjetGraphique{
public:
Cercle (int x, int y, int rayon, int
couleur=0, int epaisseur=0)
: ObjetGraphique(x, y, couleur,
epaisseur),
rayon_(rayon) {} ...
private:
int rayon_;
};

10. Composition
Cercle
- rayon_: entier
Point
- abscisse_: entier
- ordonnée_: entier
class Cercle{
public:
Cercle(…);
private:
Point centre_;
int rayon_;
};
//constructeur
Cercle::Cercle (int x, int y, int rayon)
: centre_(x,y), rayon_(rayon)
{}
« constructor» + Cercle
+ afficher()
1
centre

11. Agrégation (par pointeur)
Service
- nom_: chaîne
class Service{
private:
string nom_;
Employe* receptionniste_;
};
//constructeur
Service::Service (string nom)
: nom_(nom),
receptionniste_(NULL)
{}
//association du réceptionniste
Service::set_receptionniste(Employe* e)
{
receptionniste_ = employe;
}
//fonction principale
int main()
{
Service expedition(« Expeditions »);
Employe* e= new Employe("Michel",123);
expedition.set_receptionniste(e);
}
« constructor» + Service
+ set_receptionniste(e:Employe)
1
- nom_: entier
- identifiant_: entier
- salaire: réel
Employe
« constructor» + Employe
+ setSalaire(salaire:réel)
Peut être
nul
réceptionniste

12. Agrégation (par référence)
Service
- nom_: chaîne
- nom_: entier
- identifiant_: entier
- salaire: réel
class Service{
private:
string nom_;
Employe& receptionniste_;
};
//constructeur
Service::Service (string nom,
Employe& employe)
: nom_(nom),
receptionniste_(employe)
{}
//fonction principale
int main()
{
Employe employe(« Michel», 12568);
Service expedition(«Expéditions»,
employe);
employe.set_salaire(500);
}
Employe
1
« constructor» + Employe
+ setSalaire(salaire:réel)
« constructor» + Service
+ set_receptionniste(e:Employe)
Doit être
initialisé
réceptionniste

13. Associations
 Les associations, comme les agrégations, sont
représentées par des attributs
La différence se voit essentiellement dans le sens
Personne
- nom_: chaîne
- matricule_: chaîne
- marque_: chaîne
Voiture
0..*
appartient
0..1
class Personne{
private:
string nom_;
Liste<Voiture>* voitures_;
};
class Voiture{
private:
string matricule_;
string marque_;
Personne* proprietaire_;
};

14. Classe d’Association
Musicien
1..*
1..*
Instrument
Performance
class Performance{
private:
Musicien unMusicien;
Instrument unInstrument;
};

15. Exercice 1 : Forward
Engineering
 Réaliser en C++ le squelette du programme
qui accompagne ce diagramme
A
- x1: entier
+ faireX()
E
- x1: double
+ faireE()
D
-z1: double
- z2: double
C
+ faireZ()
B
- y1: entier
+ faireY()
F
- f1: double
+ faireF()

16. Exercice 2 : Reverse
Engineering
 Représenter le diagramme de classes UML
correspondant au squelette de code suivant:
class Department {
private : char* name_p;
public:
Department (char *dName) {
name_p = new char(sizeof(strlen(dName)));
name_p = dName;
}
char* dName();
};
class Student {
private : char* name_p;
public:
Student (char *sName) {
name_p = new char (sizeof(strlen(sName)));
name_p = sName;
}
char* sName();
};
class Course {
private:
Student * std_p;
Department * dept_p;
char * courseName_p;
static int index;
static Course *courseList[4];
public:
Course (char* crseName, Student* student,
Department* dept):
courseName_p(0), std_p(student),
dept_p(dept) { };
static char* findStudent (char *crseName,
char* deptName);
char * getStdName() ;
char * getDeptName{};
char * getCourseName();
};

17. Exercice 2: Correction