Discussion :

[Frifron]

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 ?

[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...

[Frifron]

Merci pour ta réponse !

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 :

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
 
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 :

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
 
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 ?

[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.

[Frifron]

Un truc comme ca peut être pas mal :

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
 
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

[nicroman]

Ou encore un design à la COM....

[Frifron]

Ou encore un design à la COM....

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

[dtrosset]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.