Bonjour à tous,

J'ai une question concernant la traduction de relations UML en C++: si on considère que j'ai deux classes A et B avec une relation plusieurs à plusieurs entre ces classes. J'aimerai pouvoir à partir d'un object A lister l'ensemble des objets B qui lui sont liés et à partir d'un objet B lister l'ensemble des objets A qui lui sont liés. Donc ma question : comment gérez vous ce type de relation dans vos codes? personnellement, je suis parti sur un truc du genre:
définition des classes:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class A;
class B;
 
class A
{
private:
    set<B*> _lstpB;
public:
    ~A();
    void addRelB(B* const ptB);
    void removeRelB(B * const ptB);
};
 
class B
{
private:
    set<A*> _lstpA;
public:
    ~B();
    void addRelA(A* const ptA);
    void removeRelA(A* const ptA);
};
et pour le code:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
#include "head.h"
#include <iostream>
 
A::~A()
{
    cout << "destructeur de A" << endl;
    set<B*>::iterator it = _lstpB.begin();
    while (it != _lstpB.end())
    {
        (*it)->removeRelA(this);
        it = _lstpB.begin();
    }
}
 
void A::addRelB(B* const ptB)
{
    cout << "ajout d'une relation A->B" << endl;
    if (ptB != NULL)
    {
        if (_lstpB.insert(ptB).second)
        {
            cout << "demande d'ajout d'une relation B->A" << endl;
            ptB->addRelA(this);
        }
        else
            cout << "la relation A->B existe deja" << endl;
    }
}
 
void A::removeRelB(B * const ptB)
{
    cout << "suppression d'une relation A->B" << endl;
    if (ptB != NULL)
    {
        if (_lstpB.erase(ptB) != 0)
        {
            cout << "demande de suppression d'une relation B->A" << endl;
            ptB->removeRelA(this);
        }
        else
            cout << "la relation A->B est deja supprimee" << endl;
    }
}
 
 
B::~B()
{
    cout << "destructeur de B" << endl;
    set<A*>::iterator it = _lstpA.begin();
    while (it != _lstpA.end())
    {
        (*it)->removeRelB(this);
        it = _lstpA.begin();
    }
}
 
void B::addRelA(A* const ptA)
{
    cout << "ajout d'une relation B->A" << endl;
    if (ptA != NULL)
    {
        if (_lstpA.insert(ptA).second)
        {
            cout << "demande d'ajout d'une relation A->B" << endl;
            ptA->addRelB(this);
        }
        else
            cout << "la relation B->A existe deja" << endl;
    }
}
 
void B::removeRelA(A* const ptA)
{
    cout << "suppression d'une relation B->A" << endl;
    if (ptA != NULL)
    {
        if (_lstpA.erase(ptA) != 0)
        {
            cout << "demande de suppression d'une relation A->B" << endl;
            ptA->removeRelB(this);
        }
        else
            cout << "la relation B->A est deja supprimee" << endl;
    }
}
Je me demande si c'est la bonne approche, elle me permet d'être sûr que mes données sont correctement reliées (lorsqu'on ajoute ou retire une relation ou lorsqu'un des objets est détruit) mais je trouve ça un peu "lourd" c'est pour ça que je me demande comment vous gérez les relations notamment les n-n dans vos codes C++