Discussion :

[Kaktus]

... d'autres classes.

La question posée est autant proche de l'UML que du C++.

Comme la question l'indique, je voudrai avoir votre avis sur une méthode permettant l'accès et la modification d'un même objet (donc unique) par d'autres classes :

Exemple classique :
- J'ai une classe composée d'une liste de personnes dont je souhaite par exemple effectuer des opérations comme de l'affichage (une interface graphique), une insertion d'une nouvelle personne (une autre interface graphique), une modification d'une personne de la liste (encore une autre interface graphique)...


La seule alternative que j'ai trouvée, c'est ce qui suit :

/*************** fichier header************************/

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
 
class ListePersonne {
 
        private :
        string nomliste;    [i]// Données-membres de la classe[/i]
        // ... etc..
 
        static ListePersonne* lpers;    [i] // donnée liée au singleton[/i]
 
        public :
        static ListePersonne* getObject(string name = "",...);   [i] /*Gestion du singleton, en argument de quoi construire une instance  */[/i]
        static ListePersonne* freeInstance();
 
 
        [i]// Autres fonction-membres + constructeur/ dest (privé) etc...[/i]
        };
 
 
/**************** fichier source**************************/
 
ListePersonne* ListePersonne :: lpers = NULL    [i] // Initialise à null[/i]
 
[i]/* Appel au singleton, en cas de premier appel, on le construit sinon on renvoie l'instance déjà faite */[/i]
ListePersonne* ListePersonne :: getObject(string name, ...) {
                     if (lpers == NULL) 
                                lpers = new ListePersonne(name , ...);
                     return lpers;
                     }
 
[i]/* libération de la mémoire, si besoin ... */[/i]
void ListePersonne :: freeInstance() {
                     if (lpers != NULL) {
                                delete lpers;
                                lpers = NULL;
                               };

bon ça ça va.

Voici la classe mère, qui en réalité affiche une fenêtre mais surtout instancie la ListePersonne (par intermédiaire d'un fichier ou BD par exemple);

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
 
/****************** fichier header***************************/
 
#include "ListePersonne.h"
 
class MainInterface : public IHM {       [i]// IHM peut-être une Frame par ex[/i]
 
              private :
              ListePersonne* repertoire;
 
             // .. Autres données-membres
 
 
              public :
              MainInterface( [i]//Données membres[/i])
              ~MainInterface() { repertoire = NULL; }
 
              // ... le reste
              };
 
 
 
/**************** fichier source***************************/
 
 
 MainInterface :: MainInterface() {
                        [i]// on crée la liste des personnes[/i]
              repertoire = ListePersonne :: getObject(nomdelaliste etc....);
 
              // .. Reste à initialiser;
              }

Voici une classe interface fille par exemple qui souhaite réutiliser cette ListePersonne :

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
 
/********************* fichier header**************************/
 
#include "ListePersonne.h"
 
class Interfacealpha : public IHM {        [i]// cf classe mère pour IHM[/i]
 
              private :
              ListePersonne* repertoire;
 
            [i] // .. Autres données-membres[/i]
 
              public :
              Interfacealpha( [i]//Données membres[/i])
              ~Interfacealpha() { repertoire = NULL; }  // ENCORE !!!
 
              [i]// ... le reste[/i]
              };
 
 
/********************** fichier source**********************/
 
 Interfacealpha :: Interfacealpha() {
                        [i]// on récupère la liste créée (zéro arguments)[/i]
              repertoire = ListePersonne :: getObject();
 
             [i] // .. Reste à initialiser;[/i]
              }

Cette solution marche très bien, seulement je me trimballe à chaque classe une donnée-membre (ListePersonne*) dont je suis sûr qu'il y aurait moyen de s'en débarrasser.
En plus forcément par pointeur (je dois bien transmettre par adresse).

S'il y a mieux, je suis preneur ))

[jmv]

je n'ai pas tout lu , mais il me semble que tu utilise la mèthode habituelle pour réaliser un lien (au sens UML) d'une classe vers une autre.

Quand au singleton, c'est un peu lourd, est-ce vraiment nécessaire ici ?

[Strab]

A partir du moment où tu crée un lien entre deux objets, il y en a au moins un qui connait l'adresse de l'autre. Sinon, comment pourraienst-ils communiquer ?
Donc, à moins que je n'ai pas compris ta question, ta méthode me paraît bonne.

[Jan Rendek]

Si j'ai bien compris, ton problème est plutôt comment gérer les données partagées par
plusieurs modules de ton application.
La solution que tu proposes est AMA médiocre. ListePersonne est un singleton
uniquement pour pouvoir partager la même instance de ListePersonne entre tes classes
d'interface.
La même chose est accomplie en créant l'instance à l'initialisation de l'appli et en passant
un pointeur, ou une référence sur cette instance à chacun de ses clients.

Effectivement, si beaucoup de donnée de ce type sont partagée entre beaucoup de
classes, la liste des paramètres à passer peut devenir longue.
Il est assez courant, de regrouper l'ensemble des données partagée par toute
l'application au sein d'une classe 'Monde', ou bien 'Contexte'.
Ce qui permet de ne transmettre à chaque client qu'une seule référence.