Objet (unique) d'une classe accessible et modifiable par ...
... 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:
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:
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:
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 :)))
