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

1

GPA789 Analyse et conception orientées objetGPA789 Analyse et conception orientées objet

GPA789 Analyse et conception GPA789 Analyse et conception orientées objetorientées objet

Professeur: Tony Wong, Ph.D., ing.Professeur: Tony Wong, Ph.D., ing.

Chapitre 6Chapitre 6

Correspondance UML et C++Correspondance UML et C++

Université du Québec

École de technologie supérieureDépartem ent de génie de la production autom atisée

2


Introduction (1)Introduction (1)

• Ce chapitre présente la correspondance entre Ce chapitre présente la correspondance entre certaines constructions de UML et le langage certaines constructions de UML et le langage C++.C++.

• L’objectif est de montrer une réalisation L’objectif est de montrer une réalisation possible des relations UML.possible des relations UML.

• Donc, l’importance n’est pas d’apprendre le Donc, l’importance n’est pas d’apprendre le codage par cœur mais bien de saisir codage par cœur mais bien de saisir l’expression et la sémantique du code.l’expression et la sémantique du code.

• De cette façon, il est possible de mieux juger De cette façon, il est possible de mieux juger la pertinence et l’utilisation des relations UML.la pertinence et l’utilisation des relations UML.

3


Classe simpleClasse simple

class A {class A {

public:public:

// constructeur// constructeur

A();A();

A(const A& droit);A(const A& droit);

// Destructeur// Destructeur

~A();~A();

// Opérateur d’assignation// Opérateur d’assignation

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;

};};

A

4


Classe avec attributs et opérationsClasse avec attributs et opérationsclass A {class A {public: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:private: string A1;string A1; string A2;string A2;};};

op1()op2()

A1 : stringA2 : string

A

5


Classe paramétriséeClasse paramétrisée

template <class Type>template <class Type>

class A {class A {

public:public:

A();A();

A(const A<Type>& droit);A(const A<Type>& droit);

~A();~A();

const A<Type>& operator = (const A<Type>& droit);const A<Type>& operator = (const A<Type>& droit);

bool operator == (const A<Type>& right) const;bool operator == (const A<Type>& right) const;

bool operator != (const A<Type>& right) const;bool operator != (const A<Type>& right) const;

};};

A

Type

6


Classe utilitaireClasse utilitaire

class A {class A {

public:public:

static void op1();static void op1();

static void op2();static void op2();

};};

op1()op2()

«utility»A

Sert à représenter des fonctions et des Sert à représenter des fonctions et des modules non orientés objet (Code modules non orientés objet (Code patrimoine).patrimoine).

7


Relation d’association (1)Relation d’association (1)// Déclaration anticipée de la classe B// Déclaration anticipée de la classe B

class B;class B;

// Classe A// Classe A

class A {class A {

public: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 d’association// Pour la relation d’association

const B* get_RoleB() const;const B* get_RoleB() const;

void Set_RoleB(B* const value);void Set_RoleB(B* const value);

private:private:

B * Rb;B * Rb; };};

RoleA

RoleB

1

1

A

B

8


Relation d’association (2)Relation d’association (2)// Classe B// Classe B

class B {class B {

public: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 d’association// Pour la relation d’association

const A* get_RoleA() const;const A* get_RoleA() const;

void Set_RoleA(A* const value);void Set_RoleA(A* const value);

private:private:

A* Ra;A* Ra;

};};

RoleA

RoleB

1

1

A

B

9


Association 1 à NAssociation 1 à N#include <set>#include <set>

using namespace std;using namespace std;

// Classe B// Classe B

class B {class B {

public:public:

B();B();


~B();~B();



bool operator != (const B& right) const;bool operator != (const B& right) const;

// Pour la relation d’association de multiplicité 0..*// Pour la relation d’association de multiplicité 0..*

const set<A*> get_RoleA() const;const set<A*> get_RoleA() const;

void Set_RoleA(const set<A*> value);void Set_RoleA(const set<A*> value);

private:private:

set<A*> Ra;set<A*> Ra; };};

La classe A est La classe A est identique à celle de identique à celle de l’association 1 à 1l’association 1 à 1

RoleA

RoleB

0..*

1

A

B

10


Association 1 à N avec contrainteAssociation 1 à N avec contrainte#include <list>#include <list>


// Classe B// Classe B

class B {class B {

public:public:

B();B();


~B();~B();



bool operator != (const B& right) const; bool operator != (const B& right) const; // Pour la relation d’association de multiplicité 0..* avec contrainte d’ordre// Pour la relation d’association de multiplicité 0..* avec contrainte d’ordre

const list<A*> get_RoleA() const;const list<A*> get_RoleA() const;

void Set_RoleA(const list<A*> value);void Set_RoleA(const list<A*> value);

private:private:

list<A*> Ra;list<A*> Ra; };};

RoleA

RoleB

0..*

1

A

B

{ordered}

11


Classe d’association (1)Classe d’association (1)// Fichier C.h// Fichier C.h

// Déclaration anticipée// Déclaration anticipée

class A;class A;

class B;class B;

class C {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 d’association// relation d’association

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:private:

A* _A;A* _A;

B* _B;B* _B; };};

A B1 1

C

12


Classe d’association (2)Classe d’association (2)// Fichier A.h// Fichier A.h

#include “C.h”#include “C.h”

class A {class A {

// constructeurs, destructeur et opérateurs idem aux classes// constructeurs, destructeur et opérateurs idem aux classes

// précédentes// précédentes


const C* get_C() const;const C* get_C() const;

void set_C(C* const value);void set_C(C* const value);

private:private:

C* _C;C* _C;

};};

A B1 1

C

13


Classe d’association (3)Classe d’association (3)// Fichier B.h// Fichier B.h


class B {class B {




const C* get_C() const;const C* get_C() const;

void set_C(C* const value);void set_C(C* const value);

private:private:

C* _C;C* _C;

};};

A B1 1

C

14


Classe d’association N à N (1)Classe d’association N à N (1)// Fichier C.h// Fichier C.h

// Déclaration anticipée// Déclaration anticipée

class A;class A;

class B;class B;

class C {class C { // constructeurs, destructeur et opérateurs idem aux classes précédentes// constructeurs, destructeur et opérateurs idem aux classes précédentes




const A* get_A() const;const A* get_A() const;

void set_A(A* const value);void set_A(A* const value);

private:private:

A* _A;A* _A;

B* _B;B* _B;

};};

A B0..*

C

0..*

15


Classe d’association N à N (2)Classe d’association N à N (2)// Fichier A.h// Fichier A.h

#include <set>#include <set>



class A {class A {



// relation d’association N à N// relation d’association N à N

const set<C*> get_C() const;const set<C*> get_C() const;

void set_C(const set<C*> value);void set_C(const set<C*> value);

private:private:

set<C*> _C;set<C*> _C;

};};

A B0..*

C

0..*

16


Classe d’association N à N (3)Classe d’association N à N (3)// Fichier B.h// Fichier B.h

#include <set>#include <set>



class B {class B {



// relation d’association N à N// relation d’association N à N

const set<C*> get_C() const;const set<C*> get_C() const;

void set_C(const set<C*> value);void set_C(const set<C*> value);

private:private:

set<C*> _C;set<C*> _C;

};};

A B0..*

C

0..*

17


Relation d’agrégation (1)Relation d’agrégation (1)// Déclaration anticipée// Déclaration anticipée

class B;class B;

class Aclass A

{{



// relation d’agrégation// relation d’agrégation



private:private:

B *_B;B *_B;

};};

RoleA1

1

A

B

18


Relation d’agrégation (2)Relation d’agrégation (2)class Bclass B

{{

// constructeurs, destructeur et// constructeurs, destructeur et

// opérateurs idem aux classes// opérateurs idem aux classes


////

// relation d’agrégation// relation d’agrégation


void set_RoleA(A* const value);void set_RoleA(A* const value);

private:private:

A *RoleA;A *RoleA;

};};

;;

RoleA1

1

A

B

19


Relation d’agrégation (3)Relation d’agrégation (3)– L’implantation de l’association et de l’agrégation est

identique dans cet exemple.– Or, la sémantique d’une association et celle d’une

agrégation est différente: l’une des classes est considérée comme plus importante.

– On utilise l’agrégation:• Une classe est une partie d’une autre classe;OU• Il y a propagation des valeurs d’un attribut d’une classe vers une

autre classe;OU• Une action sur une classe implique une action sur une autre

classe;OU• Les objets d’une classe sont subordonnés par les objets d’une

autre classe.

20


Relation d’agrégation avec navigation Relation d’agrégation avec navigation (1)(1)class A {class A {




////

private:private:

// aucun objet de type B (pointeur ou autre)// aucun objet de type B (pointeur ou autre)

// dans A// dans A

};};

RoleA1

1

A

B

La classe A ne peut La classe A ne peut atteindre la classe Batteindre la classe B

21


Relation d’agrégation avec navigation Relation d’agrégation avec navigation (2)(2)// Fichier B.h// Fichier B.h

#include “A.h”#include “A.h”

class B {class B {




////

// relation d’agrégation avec navigation// relation d’agrégation avec navigation


void set_RoleA(A* const value);void set_RoleA(A* const value);

private:private:

A *RoleA;A *RoleA;

};};

RoleA1

1

A

B

22


Relation de composition (1)Relation de composition (1)// Déclaration anticipée// Déclaration anticipée

class B;class B;

class A {class A {




////

// relation de composition// relation de composition



private:private:

B *_B;B *_B;

};};

RoleA1

1

A

B

23


Relation de composition (2)Relation de composition (2)class B {class B {




////


const A get_RoleA() const;const A get_RoleA() const;

void set_RoleA(const A value);void set_RoleA(const A value);

private:private:

A RoleA;A RoleA;

};};

RoleA1

1

A

B

24


Relation de composition (3)Relation de composition (3)

– La composition exprime une relation plus forte La composition exprime une relation plus forte que celle de l’agrégation;que celle de l’agrégation;

– Il indique le confinement physique des classes: Il indique le confinement physique des classes: une classe est confinée à l’intérieure d’une une classe est confinée à l’intérieure d’une autre;autre;

– Il y a équivalence entre un attribut d’une classe Il y a équivalence entre un attribut d’une classe et la relation de composition puisqu’un attribut et la relation de composition puisqu’un attribut est physiquement contenu dans une classe;est physiquement contenu dans une classe;

– La multiplicité du côté de l’agrégat (côté La multiplicité du côté de l’agrégat (côté losange du lien) est nécessairement 0 ou 1 (en losange du lien) est nécessairement 0 ou 1 (en pratique toujours 1).pratique toujours 1).

25


Réalisation alternative de la Réalisation alternative de la compositioncomposition// Déclaration anticipée// Déclaration anticipée

class B;class B;

class A {class A {




////




private:private:

B *_B;B *_B;

};};

RoleA1

1

A

B

26


Réalisation alternative de la Réalisation alternative de la compositioncompositionclass B {class B {

B() B()

{ {

// effectuer les tâches utiles ici…// effectuer les tâches utiles ici…

// créer l’objet RoleA// créer l’objet 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 l’objet RoleA// créer l’objet RoleA

RoleA = new A; RoleA = new A;

}}

Faire coïncider la Faire coïncider la durée de vie de l’objet durée de vie de l’objet de type A avec la de type A avec la durée de vie de l’objet durée de vie de l’objet de type Bde type B

27


Réalisation alternative de la Réalisation alternative de la compositioncomposition // Destructeur// Destructeur ~A()~A() {{ // effectuer les tâches utiles ici…// effectuer les tâches utiles ici… // détruire l’objet RoleA// détruire l’objet 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:private: A *RoleA;A *RoleA;};};

Faire coïncider la Faire coïncider la durée de vie de l’objet durée de vie de l’objet de type A avec la de type A avec la durée de vie de l’objet durée de vie de l’objet de type Bde type B

28


Relation de composition 1 à N (1)Relation de composition 1 à N (1)#include <set>#include <set>


class B {class B {




////

// relation de composition 1 à N// relation de composition 1 à N

const set<A> get_RoleA() const;const set<A> get_RoleA() const;

void set_RoleA(const set<A> value);void set_RoleA(const set<A> value);

private:private:

set<A> RoleA;set<A> RoleA;

};};

La classe A est identique La classe A est identique à celle de la composition à celle de la composition 1 à 11 à 1

RoleA0..*

1

A

B

29


Héritage simpleHéritage simple


class B : public A {class B : public A {

// declaration de la classe B// declaration de la classe B

////

};};

A

B

30


Héritage multipleHéritage multiple


#include “B.h”#include “B.h”

class C : public A, public B {class C : public A, public B {

// declaration de la classe C// declaration de la classe C

////

};};

A

C

B

31


Fin du chapitre 6Fin du chapitre 6

• Pratiquer l’implantation des diagrammes Pratiquer l’implantation des diagrammes UML en utilisant les exemples de codage UML en utilisant les exemples de codage contenues dans ce chapitre.contenues dans ce chapitre.

N’oubliez pas: C++ est bien plus que du C.N’oubliez pas: C++ est bien plus que du C.

Documents

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