IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

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


Sujet :

C++

  1. #1
    Membre chevronné
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    399
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 399
    Par défaut 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 ?
    SPARK
    Moteur de particule C++ opensource avec modules de rendu OpenGL, Irrlicht et SFML

  2. #2
    Membre très actif
    Avatar de TheDrev
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    310
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France, Rhône (Rhône Alpes)

    Informations forums :
    Inscription : Novembre 2006
    Messages : 310
    Par défaut
    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...

  3. #3
    Membre chevronné
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    399
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 399
    Par défaut
    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 ?
    SPARK
    Moteur de particule C++ opensource avec modules de rendu OpenGL, Irrlicht et SFML

  4. #4
    Membre très actif
    Avatar de TheDrev
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    310
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France, Rhône (Rhône Alpes)

    Informations forums :
    Inscription : Novembre 2006
    Messages : 310
    Par défaut
    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.

  5. #5
    Membre chevronné
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    399
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 399
    Par défaut
    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
    SPARK
    Moteur de particule C++ opensource avec modules de rendu OpenGL, Irrlicht et SFML

  6. #6
    Expert confirmé

    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    4 253
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Février 2007
    Messages : 4 253
    Billets dans le blog
    3
    Par défaut
    Ou encore un design à la COM....

  7. #7
    Membre chevronné
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    399
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 399
    Par défaut
    Citation Envoyé par nicroman Voir le message
    Ou encore un design à la COM....
    ? Désolé, j'ai pas compris...
    SPARK
    Moteur de particule C++ opensource avec modules de rendu OpenGL, Irrlicht et SFML

  8. #8
    Membre très actif

    Inscrit en
    Juillet 2008
    Messages
    186
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 186
    Par défaut
    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.

Discussions similaires

  1. script tri tableau sur plusieur niveau
    Par Invité dans le forum Bibliothèques et frameworks
    Réponses: 3
    Dernier message: 29/10/2013, 22h32
  2. Réponses: 8
    Dernier message: 19/07/2013, 14h18
  3. gérer plusieurs graphiques sur une interface
    Par olivyeye dans le forum Interfaces Graphiques
    Réponses: 1
    Dernier message: 17/11/2008, 16h03
  4. Réponses: 4
    Dernier message: 05/05/2008, 11h43

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo