plusieurs niveau d'accessibilité sur l'interface d'un objet

Version imprimable

27/08/2008, 18h48
Frifron

plusieurs niveau d'accessibilité sur l'interface d'un objet

Bonjour je code un conteneur et j'aimerai avoir plusieurs niveau d'interface. Je m'explique : en gros j'aimerai séparé l'accessibilité de modification des objets contenu et l'accessibilité de la modification de la liste des objets du conteneur.

Un niveau d'accessibilité serait donc (on va l'appeler niveau 1) :
_ acces aux objets contenus
_ acces a l'interface du conteneur ne modifiant pas directement la liste des objets contenus (accesseurs (taille...),

L'autre niveau serait l'acces a l'interface complète (on va l'appeler niveau 2) :
_ acces a tout plus haut
_ acces a l'interface permettant de modifier la liste des objets contenus (ajout, retrait, swap...)

J'avais penser utiliser le pattern lettre enveloppe avec l'l'enveloppe contenant l'interface niveau 1 et la lettre contenant l'interface niveau 2 mais c'est assez galère parceque ca m'empeche d'utiliser la surcharge de méthode (a cause des types de retour qui diffèrent (des const ou pas)) pour tout ce qui est méthode/opérateur d'acces a la liste des éléments.

Voyez vous un moyen de faire ca proprement ?
28/08/2008, 11h11
TheDrev

Salut, tu peut jouer avec l'encapsulation même si tu n'auras pas exactement ce que tu veux faire.

Si tu veux absolument utiliser un pattern je te conseillerai plutôt le proxy...

Merci pour ta réponse !

Citation:

Salut, tu peut jouer avec l'encapsulation même si tu n'auras pas exactement ce que tu veux faire.

De quelle manière voit tu la chose ?

En fait ce que je veux faire, permettre a une classe d'avoir un acces complet sur le conteneur qu'elle contient et permettre à l'utilisateur de la classe d'avoir un acces limité au conteneur.

Je pourrais faire un truc dans le style (pattern lettre-enveloppe):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class MyLimitedContainer { void accessibleMethod(); }; class MyContainer : public MyLimitedContainer { void methodWithLimitedAccess(); }; class A { public : MyLimitedContainer& getContainer(); private : MyContainer container; };
Mais ca me convient moyennement car :
_ la surchage est contrainte a cause des types de retour qui vont différer (const...)
_ un dynamic cast permet au final d'accéder a l'interface "complete" du conteneur

Sinon avec un pattern proxy :
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 class MyContainer { public : void accessibleMethod(); void methodWithLimitedAccess(); ... }; class ContainerOwner { public : void accessibleMethod(); ... protected : MyContainer container; }; class A : public ContainerOwner { ... }; void ContainerOwner::accessibleMethod() { container.accessibleMethod(); }
Mais la ca me limite le nombre de conteneur par classe à 1 seul, or je ne veux pas que ce soit le cas.

Quelqu un aurait une idée ?

28/08/2008, 13h25
TheDrev

Pour l encaptulation, met le maximum de fonctions en private ou protected, puis utilise le proxy comme un "super getter".

Tu peut passer des paramétrs au proxy pour avoir plusieurs conteneur. C'est très courant, Java effectue carrément les traitement en fonction du nom de la méthode passé en argument.

Un truc comme ca peut être pas mal :

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
36
37
38
39
40
41
42
 
class MyContainer
{
public :
 
    void accesibleMethod();
    void methodWithLimitedAccess();
};
 
class MyContainerWrapper
{
public :
 
    MyContainerWrapper(MyContainer* container);
 
    void accesibleMethod();
 
private :
 
    MyContainer* const container;
};
 
class A
{
public :
 
    MyContainerWrapper& getContainerWrapperA();
    MyContainerWrapper& getContainerWrapperB();
 
private :
 
    MyContainer containerA;
    MyContainer containerB;
 
    MyContainerWrapper containerWrapperA;
    MyContainerWrapper containerWrapperB;
};
 
void MyContainerWrapper::accessibleMethod()
{
    container->accessibleMethod();
}

Ca vous parait bien comme design ? Ou eventuellement inclure MyContainerWrapper directement dans MyContainer

29/08/2008, 02h29
nicroman

Ou encore un design à la COM....
29/08/2008, 02h46
Frifron

Citation:

Envoyé par nicroman

Ou encore un design à la COM....

? Désolé, j'ai pas compris...

Et pourquoi pas std::vector<T *> (ou tou autre conteneur non associatif). En effet, un objet constant d'une telle class econteneur permet l'accès aux objects contenus, mais ne permet pas de modifier le conteneur. Un objet non constant permettra lui d'effectuer les ajouts et supressions ...
Code:

1 2 3 typedef std::vector<MaClasse *> MonConteneur; MonConteneur c; // permet ajouts, supressions, ... tout en fait MonConteneur const &cc = c; // ne permet que l'accès aux objets contenus
Un petit détail, la version limitée permet quand même de faire un delete sur l'objet contenu.