Section
1
Correspondance entre le UML et le C++
Exemples de codage
Introduction
Ce document pr sente quelques exemples de codage qui traduisent la correspondance
entre le mod le exprim en UML et les instructions en langage C++. Ces exemples
sont donn s sous forme tabulaire afin de faciliter leur compr hension.
Les classes repr sent es sont dot es de deux constructeurs (un constructeur par
d faut et un constructeur de copie), dun destructeur et de trois op rateurs. Il sagit l
dune pratique courante et recommand e par les praticiens du domaine. videmment,
limplantation concr te de ces fonctions membres d pendra de lapplication r elle des
classes. Le r le des op rateurs dassignation (=), d galit (==) et de lin galit (!=) est
de simplifier linsertion des objets dans des classes collections. Cette manipulation et
dautres seront n cessaires lorsque la multiplicit des objets dans une relation est
sup rieure 1.
Il existe plusieurs fa ons de r aliser les relations UML. Le codage pr sent dans ce
document ne montre que le principe de base de limplantation des relations. Ainsi,
une association, une agr gation et une composition sont toutes r alis es laide de
pointeurs dobjet. Certaines de ces relations auraient pu tre r alis es par des variables
membres ordinaires. Limportance dans ces cas est le respect de la nature des relations
et la dur e de vie des objets.
noter galement que certains exemples codage supposent que les classes sont
d clar es dans un seul fichier den-t te tandis que dautres exemples supposent que les
classes sont d clar es dans des fichiers .h s par s. Un commentaire C++ vous
donnera lindication lorsque les classes sont d clar es dans des fichiers s par s.
Classes simples
Classe Simple
A
class A {
public:
// constructeur
A();
A(const A& droit);
// Destructeur
~A();
// Op rateur dassignation
Classe avec attributs et
op rations
A
A1 : string
A2 : string
op1()
op2()
const A& operator = (const A& droit);
// Autres op rations
bool operator == (const A& droit) const;
bool operator != (const A& droit) const;
};
class A {
public:
// constructeur
A();
A(const A& droit);
// Destructeur
~A();
// Op rateur dassignation
const A& operator = (const A& droit);
// Autres op rations
bool operator == (const A& droit) const;
bool operator != (const A& droit) const;
// Op rations sp cifiques la classe
const string get_A1() const;
void set_A1(const string valeur);
const string get_A2() const;
void set_A2(const string valeur);
private:
string A1;
string A2;
};
// Quelques implantations
const string A::get_A1() const { return A1; }
void A::set_A1(const string valeur) { A1 = valeur; }
const string A::get_A2() const { return A2; }
void A::set_A2(const string valeur) { A2 = valeur; }
Classe param tris e
Type
A
template <class Type>
class A {
public:
A();
A(const A<Type>& droit);
~A();
const A<Type>& operator = (const A<Type>& droit);
bool operator == (const A<Type>& right) const;
bool operator != (const A<Type>& right) const;
};
Classe utilitaire
utility
A
class A {
public:
static void op1();
static void op2();
};
op1()
op2()
3
Publicité
Relations dassociation
Association 1 1
1
1
A
B
RoleA
RoleB
// D claration anticip e de la classe B
class B;
// Classe A
class A {
public:
A();
A(const A& droit);
~A();
const A& operator = (const A& droit);
bool operator == (const A& right) const;
bool operator != (const A& right) const;
// Pour la relation dassociation
const B* get_RoleB() const;
void Set_RoleB(B* const value);
private:
B * Rb;
};
const B* A::get_RoleB() const { return Rb; }
void A::set_RoleB(B* const value) { Rb = value; }
// Classe B
class B {
public:
B();
B(const B& droit);
~B();
const B& operator = (const B& droit);
bool operator == (const B& right) const;
bool operator != (const B& right) const;
// Pour la relation dassociation
const A* get_RoleA() const;
void Set_RoleA(A* const value);
private:
A* Ra;
};
const A* B::get_RoleA() const { return Ra; }
void B::set_RoleA(A* const value) { Ra = value; }
Association N 1
Classe A identique celle dune association 1 1
#include <set>
using namespace std;
// Classe B
class B {
public:
4
A
0..*
RoleA
1
RoleB
B
Association N 1 avec
contrainte
{ordered}
A
0..*
RoleA
1
RoleB
B
B();
B(const B& droit);
~B();
const B& operator = (const B& droit);
bool operator == (const B& right) const;
bool operator != (const B& right) const;
// Pour la relation dassociation de
// multiplicit 0..*
const set<A*> get_RoleA() const;
void Set_RoleA(const set<A*> value);
private:
set<A*> Ra;
};
const set<A*> B::get_RoleA() const { return Ra; }
void B::set_RoleA(const set<A*> value)
{ Ra = value; }
Classe A identique celle dune association 1 1
#include <list>
using namespace std;
// Classe B
class B {
public:
B();
B(const B& droit);
~B();
const B& operator = (const B& droit);
bool operator == (const B& right) const;
bool operator != (const B& right) const;
// Pour la relation dassociation de
// multiplicit 0..* avec contrainte dordre
const list<A*> get_RoleA() const;
void Set_RoleA(const list<A*> value);
Publicité
private:
list<A*> Ra;
};
const list<A*> B::get_RoleA() const { return Ra; }
void B::set_RoleA(const list<A*> value)
{ Ra = value; }
5
Classe dassociation
A
B
1
1
C
// Fichier C.h
// D claration anticip e
class A;
class B;
class C {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dassociation
const B* get_B() const;
void set_B(B* const value);
const A* get_A() const;
void set_A(A* const value);
private:
A* _A;
B* _B;
};
// Fichier A.h
#include C.h
class A {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dassociation
const C* get_C() const;
void set_C(C* const value);
private:
C* _C;
};
// Fichier B.h
#include C.h
class B {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dassociation
const C* get_C() const;
void set_C(C* const value);
private:
C* _C;
};
6
Classe dassociation N N
A
0..*
0..*
B
C
// Fichier C.h
// D claration anticip e
class A;
class B;
class C {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dassociation
const B* get_B() const;
void set_B(B* const value);
const A* get_A() const;
void set_A(A* const value);
private:
A* _A;
B* _B;
};
// Fichier A.h
#include <set>
#include C.h
using namespace std;
class A {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dassociation N N
const set<C*> get_C() const;
void set_C(const set<C*> value);
private:
set<C*> _C;
};
7
// Fichier B.h
Publicité
#include <set>
#include C.h
using namespace std;
class B {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dassociation N N
const set<C*> get_C() const;
void set_C(const set<C*> value);
private:
set<C*> _C;
};
Relations dagr gation
Agr gation 1 1
// D claration anticip e
class B;
RoleA
1
1
A
B
class A
{
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dagr gation
const B* get_B() const;
void set_B(B* const value);
private:
B *_B;
};
class B
{
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dagr gation
const A* get_RoleA() const;
void set_RoleA(A* const value);
private:
A *RoleA;
};
8
Agr gation avec navigation
Classe A ne peut pas atteindre classe B
RoleA
1
1
A
B
class A {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
private:
// aucun objet de type B (pointeur ou autre)
// dans A
};
// Fichier B.h
#include A.h
class B {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation dagr gation avec navigation
const A* get_RoleA() const;
void set_RoleA(A* const value);
private:
A *RoleA;
};
Relations de composition
Composition
// D claration anticip e
class B;
RoleA
1
1
A
B
class A {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation de composition
const B* get_B() const;
void set_B(B* const value);
private:
B *_B;
};
class B {
// constructeurs, destructeur et
Publicité
// op rateurs idem aux classes
// pr c dentes
//
// relation de composition
9
const A get_RoleA() const;
void set_RoleA(const A value);
private:
A RoleA;
};
Une r alisation alternative
de la composition
// D claration anticip e
class B;
class A {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation de composition
const B* get_B() const;
void set_B(B* const value);
private:
B *_B;
};
class B {
B()
{
// effectuer les t ches utiles ici&
// cr er lobjet RoleA
RoleA = new A;
}
A(const A& droit)
{
// effectuer les t ches utiles ici&
// cr er lobjet RoleA
RoleA = new A;
}
// Destructeur
~A()
{
// effectuer les t ches utiles ici&
// d truire lobjet RoleA
delete RoleA;
}
// Autres op rateurs idem aux classes
// pr c dentes
//
// relation de composition
const A* get_RoleA() const;
void set_RoleA(A* const value);
private:
A *RoleA;
};
10
Composition 1 N
Classe A identique celle dune composition 1 1
A
0..*
RoleA
1
B
#include <set>
using namespace std;
class B {
// constructeurs, destructeur et
// op rateurs idem aux classes
// pr c dentes
//
// relation de composition 1 N
const set<A> get_RoleA() const;
void set_RoleA(const set<A> value);
private:
set<A> RoleA;
};
H ritage
H ritage simple
A
B
#include A.h
class B : public A {
// declaration de la classe B
//
};
H ritage multiple
#include A.h
#include B.h
A
B
class C : public A, public B {
// declaration de la classe C
//
};
C
11