Le document traite de la génération de code et de la rétro-ingénierie à partir de diagrammes UML vers C++, décrivant des concepts clés comme la traduction de modèles UML en code, les attributs et méthodes des classes, ainsi que les relations comme héritage et agrégation. Il inclut des exemples de code C++ pour illustrer les concepts de classes, méthodes abstraites, associations et la structuration du développement logiciel. Enfin, il propose des exercices sur l'ingénierie directe et inverse pour renforcer la compréhension de ces concepts.

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

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
« constructor» + Cercle
+ afficher()
centre
1
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)
{}

11. Agrégation (par pointeur)
Service
- nom_: chaîne
« constructor» + Service
+ set_receptionniste(e:Employe)
réceptionniste
1
Employe
- nom_: entier
- identifiant_: entier
- salaire: réel
« constructor» + Employe
+ setSalaire(salaire:réel)
class Service{
private:
string nom_;
Employe* receptionniste_;
};
//constructeur
Service::Service (string nom)
Peut être
: nom_(nom),
nul
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);
}

12. Agrégation (par référence)
Service
- nom_: chaîne
« constructor» + Service
+ set_receptionniste(e:Employe)
réceptionniste
1
Employe
- nom_: entier
- identifiant_: entier
- salaire: réel
« constructor» + Employe
+ setSalaire(salaire:réel)
class Service{
private:
string nom_;
Employe& receptionniste_;
};
Doit être
//constructeur
initialisé
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);
}

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
0..1
appartient
0..*
Voiture
- matricule_: chaîne
- marque_: chaîne
class Personne{
private:
string nom_;
Liste<Voiture>* voitures_;
};
class Voiture{
private:
string matricule_;
string marque_;
Personne* proprietaire_;
};

14. Classe d’Association
Musicien
1..*
Instrument
1..*
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
E
- x1: entier
- x1: double
+ faireX()
+ faireE()
B
C
D
- y1: entier
+ faireY()
-z1: double
- z2: double
+ faireZ()
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