GPA789 Analyse et conception orientées objet 1 Professeur: Tony Wong, Ph.D., ing. Chapitre 6 Correspondance UML et C++

Présentation au sujet: "GPA789 Analyse et conception orientées objet 1 Professeur: Tony Wong, Ph.D., ing. Chapitre 6 Correspondance UML et C++"— Transcription de la présentation:

1 GPA789 Analyse et conception orientées objet 1 Professeur: Tony Wong, Ph.D., ing. Chapitre 6 Correspondance UML et C++

2 GPA789 Analyse et conception orientées objet 2 Introduction (1) Ce chapitre présente la correspondance entre certaines constructions de UML et le langage C++.Ce chapitre présente la correspondance entre certaines constructions de UML et le langage C++. Lobjectif est de montrer une réalisation possible des relations UML.Lobjectif est de montrer une réalisation possible des relations UML. Donc, limportance nest pas dapprendre le codage par cœur mais bien de saisir lexpression et la sémantique du code.Donc, limportance nest pas dapprendre le codage par cœur mais bien de saisir lexpression et la sémantique du code. De cette façon, il est possible de mieux juger la pertinence et lutilisation des relations UML.De cette façon, il est possible de mieux juger la pertinence et lutilisation des relations UML.

3 GPA789 Analyse et conception orientées objet 3 Classe simple class A { public: // constructeur // constructeur A(); A(); A(const A& droit); A(const A& droit); // Destructeur // Destructeur ~A(); ~A(); // Opérateur dassignation // Opérateur dassignation const A& operator = (const A& droit); const A& operator = (const A& droit); // Autres opérations // Autres opérations bool operator == (const A& droit) const; bool operator == (const A& droit) const; bool operator != (const A& droit) const; bool operator != (const A& droit) const;};

4 GPA789 Analyse et conception orientées objet 4 Classe avec attributs et opérations class A { public: A(); A(); A(const A& droit); A(const A& droit); ~A(); ~A(); const A& operator = (const A& droit); const A& operator = (const A& droit); bool operator == (const A& droit) const; bool operator == (const A& droit) const; bool operator != (const A& droit) const; bool operator != (const A& droit) const; // Opérations spécifiques à la classe // Opérations spécifiques à la classe const string get_A1() const; const string get_A1() const; void set_A1(const string valeur); void set_A1(const string valeur); const string get_A2() const; const string get_A2() const; void set_A2(const string valeur); void set_A2(const string valeur);private: string A1; string A1; string A2; string A2;};

5 GPA789 Analyse et conception orientées objet 5 Classe paramétrisée template template class A { public: A(); A(); A(const A & droit); A(const A & droit); ~A(); ~A(); const A & operator = (const A & droit); const A & operator = (const A & droit); bool operator == (const A & right) const; bool operator == (const A & right) const; bool operator != (const A & right) const; bool operator != (const A & right) const;};

6 GPA789 Analyse et conception orientées objet 6 Classe utilitaire class A { public: static void op1(); static void op1(); static void op2(); static void op2();}; Sert à représenter des fonctions et des modules non orientés objet (Code patrimoine).

7 GPA789 Analyse et conception orientées objet 7 Relation dassociation (1) // Déclaration anticipée de la classe B class B; // Classe A class A { public: A(); A(); A(const A& droit); A(const A& droit); ~A(); ~A(); const A& operator = (const A& droit); const A& operator = (const A& droit); bool operator == (const A& right) const; bool operator == (const A& right) const; bool operator != (const A& right) const; bool operator != (const A& right) const; // Pour la relation dassociation // Pour la relation dassociation const B* get_RoleB() const; const B* get_RoleB() const; void Set_RoleB(B* const value); void Set_RoleB(B* const value);private: B * Rb; }; B * Rb; };

8 GPA789 Analyse et conception orientées objet 8 Relation dassociation (2) // Classe B class B { public: B(); B(); B(const B& droit); B(const B& droit); ~B(); ~B(); const B& operator = (const B& droit); const B& operator = (const B& droit); bool operator == (const B& right) const; bool operator == (const B& right) const; bool operator != (const B& right) const; bool operator != (const B& right) const; // Pour la relation dassociation // Pour la relation dassociation const A* get_RoleA() const; const A* get_RoleA() const; void Set_RoleA(A* const value); void Set_RoleA(A* const value); private: A* Ra; A* Ra;};

9 GPA789 Analyse et conception orientées objet 9 Association 1 à N #include #include using namespace std; // Classe B class B { public: B(); B(); B(const B& droit); B(const B& droit); ~B(); ~B(); const B& operator = (const B& droit); const B& operator = (const B& droit); bool operator == (const B& right) const; bool operator == (const B& right) const; bool operator != (const B& right) const; bool operator != (const B& right) const; // Pour la relation dassociation de multiplicité 0..* // Pour la relation dassociation de multiplicité 0..* const set get_RoleA() const; const set get_RoleA() const; void Set_RoleA(const set value); void Set_RoleA(const set value); private: set Ra; }; set Ra; }; La classe A est identique à celle de lassociation 1 à 1

10 GPA789 Analyse et conception orientées objet 10 Association 1 à N avec contrainte #include #include using namespace std; // Classe B class B { public: B(); B(); B(const B& droit); B(const B& droit); ~B(); ~B(); const B& operator = (const B& droit); const B& operator = (const B& droit); bool operator == (const B& right) const; bool operator == (const B& right) const; bool operator != (const B& right) const; bool operator != (const B& right) const; // Pour la relation dassociation de multiplicité 0..* avec contrainte dordre // Pour la relation dassociation de multiplicité 0..* avec contrainte dordre const list get_RoleA() const; const list get_RoleA() const; void Set_RoleA(const list value); void Set_RoleA(const list value); private: list Ra; }; list Ra; };

11 GPA789 Analyse et conception orientées objet 11 Classe dassociation (1) // Fichier C.h // Déclaration anticipée class A; class B; class C { // constructeurs, destructeur et opérateurs idem aux // constructeurs, destructeur et opérateurs idem aux // classes précédentes // classes précédentes // relation dassociation // relation dassociation const B* get_B() const; const B* get_B() const; void set_B(B* const value); void set_B(B* const value); const A* get_A() const; const A* get_A() const; void set_A(A* const value); void set_A(A* const value);private: A* _A; A* _A; B* _B; }; B* _B; };

12 GPA789 Analyse et conception orientées objet 12 Classe dassociation (2) // Fichier A.h #include C.h class A { // constructeurs, destructeur et opérateurs idem aux classes // constructeurs, destructeur et opérateurs idem aux classes // précédentes // précédentes // relation dassociation // relation dassociation const C* get_C() const; const C* get_C() const; void set_C(C* const value); void set_C(C* const value); private: C* _C; C* _C;};

13 GPA789 Analyse et conception orientées objet 13 Classe dassociation (3) // Fichier B.h #include C.h class B { // constructeurs, destructeur et opérateurs idem aux classes // constructeurs, destructeur et opérateurs idem aux classes // précédentes // précédentes // relation dassociation // relation dassociation const C* get_C() const; const C* get_C() const; void set_C(C* const value); void set_C(C* const value); private: C* _C; C* _C;};

14 GPA789 Analyse et conception orientées objet 14 Classe dassociation N à N (1) // Fichier C.h // Déclaration anticipée class A; class B; class C { // constructeurs, destructeur et opérateurs idem aux classes précédentes // constructeurs, destructeur et opérateurs idem aux classes précédentes // relation dassociation // relation dassociation const B* get_B() const; const B* get_B() const; void set_B(B* const value); void set_B(B* const value); const A* get_A() const; const A* get_A() const; void set_A(A* const value); void set_A(A* const value);private: A* _A; A* _A; B* _B; B* _B;};

15 GPA789 Analyse et conception orientées objet 15 Classe dassociation N à N (2) // Fichier A.h #include #include #include C.h using namespace std; class A { // constructeurs, destructeur et opérateurs idem aux classes // constructeurs, destructeur et opérateurs idem aux classes // précédentes // précédentes // relation dassociation N à N // relation dassociation N à N const set get_C() const; const set get_C() const; void set_C(const set value); void set_C(const set value); private: set _C; set _C;};

16 GPA789 Analyse et conception orientées objet 16 Classe dassociation N à N (3) // Fichier B.h #include #include #include C.h using namespace std; class B { // constructeurs, destructeur et opérateurs idem aux classes // constructeurs, destructeur et opérateurs idem aux classes // précédentes // précédentes // relation dassociation N à N // relation dassociation N à N const set get_C() const; const set get_C() const; void set_C(const set value); void set_C(const set value); private: set _C; set _C;};

17 GPA789 Analyse et conception orientées objet 17 Relation dagrégation (1) // Déclaration anticipée class B; class A { // constructeurs, destructeur et opérateurs idem aux classes // constructeurs, destructeur et opérateurs idem aux classes // précédentes // précédentes // relation dagrégation // relation dagrégation const B* get_B() const; const B* get_B() const; void set_B(B* const value); void set_B(B* const value);private: B *_B; B *_B;};

18 GPA789 Analyse et conception orientées objet 18 Relation dagrégation (2) class B { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // // relation dagrégation // relation dagrégation const A* get_RoleA() const; const A* get_RoleA() const; void set_RoleA(A* const value); void set_RoleA(A* const value);private: A *RoleA; A *RoleA;};;

19 GPA789 Analyse et conception orientées objet 19 Relation dagrégation (3) – –Limplantation de lassociation et de lagrégation est identique dans cet exemple. – –Or, la sémantique dune association et celle dune agrégation est différente: lune des classes est considérée comme plus importante. – –On utilise lagrégation: Une classe est une partie dune autre classe; OU Il y a propagation des valeurs dun attribut dune classe vers une autre classe; OU Une action sur une classe implique une action sur une autre classe; OU Les objets dune classe sont subordonnés par les objets dune autre classe.

20 GPA789 Analyse et conception orientées objet 20 Relation dagrégation avec navigation (1) class A { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // private: // aucun objet de type B (pointeur ou autre) // aucun objet de type B (pointeur ou autre) // dans A // dans A}; La classe A ne peut atteindre la classe B

21 GPA789 Analyse et conception orientées objet 21 Relation dagrégation avec navigation (2) // Fichier B.h #include A.h class B { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // // relation dagrégation avec navigation // relation dagrégation avec navigation const A* get_RoleA() const; const A* get_RoleA() const; void set_RoleA(A* const value); void set_RoleA(A* const value);private: A *RoleA; A *RoleA;};

22 GPA789 Analyse et conception orientées objet 22 Relation de composition (1) // Déclaration anticipée class B; class A { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // // relation de composition // relation de composition const B* get_B() const; const B* get_B() const; void set_B(B* const value); void set_B(B* const value);private: B *_B; B *_B;};

23 GPA789 Analyse et conception orientées objet 23 Relation de composition (2) class B { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // // relation de composition // relation de composition const A get_RoleA() const; const A get_RoleA() const; void set_RoleA(const A value); void set_RoleA(const A value);private: A RoleA; A RoleA;};

24 GPA789 Analyse et conception orientées objet 24 Relation de composition (3) –La composition exprime une relation plus forte que celle de lagrégation; –Il indique le confinement physique des classes: une classe est confinée à lintérieure dune autre; –Il y a équivalence entre un attribut dune classe et la relation de composition puisquun attribut est physiquement contenu dans une classe; –La multiplicité du côté de lagrégat (côté losange du lien) est nécessairement 0 ou 1 (en pratique toujours 1).

25 GPA789 Analyse et conception orientées objet 25 Réalisation alternative de la composition // Déclaration anticipée class B; class A { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // // relation de composition // relation de composition const B* get_B() const; const B* get_B() const; void set_B(B* const value); void set_B(B* const value);private: B *_B; B *_B;};

26 GPA789 Analyse et conception orientées objet 26 Réalisation alternative de la composition class B { B() B() { // effectuer les tâches utiles ici… // effectuer les tâches utiles ici… // créer lobjet RoleA // créer lobjet RoleA RoleA = new A; RoleA = new A; } A(const A& droit) A(const A& droit) { // effectuer les tâches utiles ici… // effectuer les tâches utiles ici… // créer lobjet RoleA // créer lobjet RoleA RoleA = new A; RoleA = new A; } Faire coïncider la durée de vie de lobjet de type A avec la durée de vie de lobjet de type B

27 GPA789 Analyse et conception orientées objet 27 Réalisation alternative de la composition // Destructeur // Destructeur ~A() ~A() { // effectuer les tâches utiles ici… // effectuer les tâches utiles ici… // détruire lobjet RoleA // détruire lobjet RoleA delete RoleA; delete RoleA; } // Autres opérateurs idem aux classes // Autres opérateurs idem aux classes // précédentes // précédentes // // // relation de composition // relation de composition const A* get_RoleA() const; const A* get_RoleA() const; void set_RoleA(A* const value); void set_RoleA(A* const value);private: A *RoleA; A *RoleA;}; Faire coïncider la durée de vie de lobjet de type A avec la durée de vie de lobjet de type B

28 GPA789 Analyse et conception orientées objet 28 Relation de composition 1 à N (1) #include #include using namespace std; class B { // constructeurs, destructeur et // constructeurs, destructeur et // opérateurs idem aux classes // opérateurs idem aux classes // précédentes // précédentes // // // relation de composition 1 à N // relation de composition 1 à N const set get_RoleA() const; const set get_RoleA() const; void set_RoleA(const set value); void set_RoleA(const set value);private: set RoleA; set RoleA;}; La classe A est identique à celle de la composition 1 à 1

29 GPA789 Analyse et conception orientées objet 29 Héritage simple #include A.h class B : public A { // declaration de la classe B // };

30 GPA789 Analyse et conception orientées objet 30 Héritage multiple #include A.h #include B.h class C : public A, public B { // declaration de la classe C // };

31 GPA789 Analyse et conception orientées objet 31 Fin du chapitre 6 Pratiquer limplantation des diagrammes UML en utilisant les exemples de codage contenues dans ce chapitre.Pratiquer limplantation des diagrammes UML en utilisant les exemples de codage contenues dans ce chapitre. Noubliez pas: C++ est bien plus que du C.