Probl�me encapsulation C++

Version imprimable

30/10/2007, 10h22
LePetitBricoleur

Probl�me encapsulation C++

Bonjour!

J'ai un petit probl�me. J'ai une classe qui a �t� d�finie comme membre d'une autre classe
voil� comment je proc�de pour coder les differentes methodes de la classe 2

classe1::classe2::method()

il se trouve que la classe 2 est un membre protected de la classe1

A l'interieur d'une methode de la classe 2, j'aimerais acceder � certains membres protected de la classe 1 et le compilateur me dit que c'est pas possible

en gros j'ai un membre classe protected qui veut dans l'une de ses methodes avoir acc�s � un membre protected de la classe dans laquelle elle est definie..

Est ce normal que je puisse pas y avoir acc�s?
30/10/2007, 10h29
bolhrak

Oui c'est normal, les classes imbriqu�es en C++ n'ont pas de privil�ge d'acc�s sur les classes encapsulantes.

Salut,

La classe "classe2" n'est pas d�finie comme membre de la classe "classe1" mais comme... classe imbriqu�e... fusse-elle une classe "anonyme" :D

Le fait que, par la suite, tu aie d�clar� un membre du type de la classe imbriqu�e ne changera rien :roll:

Il faut savoir que, d�s le moment o� tu utilise le mot cl� class pour d�finir une nouvelle structure, tu encapsule irr�m�diablement tout ce qu'elle peut contenir.

C'est exactement ce qui se passe avec les espaces de nommages:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 namespace MonNameSpace { void foo(MaClasse&); class MaClasse { public: /*foo a acces a tout ce qui est public ... */ protected : /*... mais à rien de ce qui est protected ... */ private: /* ... ou private ...*/ }; };
Si tu veux que, dans ton exemple, classe1 puisse acc�der directement aux membres protected et/ou private de classe2, il faudra signaler l'amiti� de classe1 pour classe2 :D, ce qui ne change d'ailleurs absolument pas de ce qui doit �tre fait avec deux classes bien distinctes...

Le fait de d�clarer des classes imbriqu�es n'apporte, en r�alit�, qu'un seul avantage par rapport � celui de d�clarer des classes distinctes, et qui est celui que l'on retrouve dans l'utilisation des espaces de nommage: le nom du type cr�� devient "d�pendant" de l'espace de nommage/la classe dans le(la)quel(le) il est d�fini, et peut donc �tre r�utilis� ailleurs :D

02/11/2007, 12h04
LePetitBricoleur

probl�me encapsulation
dans ce cas dans une structure de classe imbriqu�es:
Code:

1 2 3 4 5 6 7 8 9 10 11 class classe1 { protected: Methode_classe1() ; class classe2 { protected: membre_classe2 ; } }
Comment je dois proc�der pour pouvoir avoir acc�s � membre_classe2 en etant dans l'ecriture de la definition de Methode_classe1() ?
Ou comment puis-je modifier la valeur de membre_classe2 en etant dans Methode_classe1()?

Je vous remercie d'avance
02/11/2007, 12h08
Alp

Il te faut 1) une instance de la classe int�rieure 2) un couple accesseur/mutateur pour ton attribut
02/11/2007, 12h44
LePetitBricoleur

reponse a Alp

d�sol� Alp mais franchement je suis un debutant j'ai rien compris � la 2)
c'est quoi un couple accesseur/mutateur?

merci

une instance de la classe sup�rieure
d�clarer la classe sup�rieure comme amie de la classe imbriqu�e.

Au final, tu as donc deux solutions:

Celle propos�e par Alp (:salut:) qui prend la forme de

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
 
class Classe1
{
     public:
    class classe2
    {
        public:
            Classe2();//constructeur
            ~Classe2();//destructeur
            /*const */ type /*&*/ GetMembre()/*const*/
            {
                return membre_classe2;
            }
            void SetMembre(/*const*/ type /*&*/ newval)
            {
                 membre_classe2=newval;
            }
        protected:
            type membre_classe2 ;
    };
         Classe1();//constructeur
         ~Classe1();//destructeur
         /*const */ type /*&*/ GetMembreClass2()/*const*/
         {
             return m1.GetMembre();
         }
         /* voir, pourquoi pas */
         void ModifyMembreClass2(/* const */ type /*&*/ newval)
         {
              m1.SetMembre(newval);
         }
    protected:
    Methode_classe1()
    {
         type laval=m1.GetMembre();
         /* voir */
         m1.SetMembre( nouvelle_valeur_de_type_type);
    }
    private:
        Classe2 m1;
};

qui permet une utilisation sous la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
/*soit, on travaille uniquement avec Classe2 */
Classe1::Classe2 obj;
/* pour la modification du membre */
obj.SetMembre(nouvelle_valeur);
/*ou, pour l'acces au membre */
type lemembre=obj.GetMembre();
/* soit on travaille uniquement avec Classe1 */
Classe1  autre_obj();
/* pour récupérer la valeur */
type lemembre_de_m1=autre_obj.GetMembreClass2();
/* pour modifier la valeur */
autre_obj.ModifyMembreClass2(nouvelle_valeur);

Ou, si tu estimes peu coh�rent de permettre de modifier la valeur du membre autrement que par l'acc�s via Class1, tu peux envisager une relation d'amiti� sous la forme de

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
 
class Classe1
{
    public:
    class classe2
    {
        public:
            Classe2();//constructeur
            ~Classe2();//destructeur
      /* ni mutateur, ni accesseur... Personne n'a acces à membre_class2*/
        private:
            type membre_classe2 ;
            /* sauf Class1, grâce à l'amitié */
            friend class Class1;
    };
        Classe1();//constructeur
        Classe1();//destructeur
         /*const */ type /*&*/ GetMembreClass2()/*const*/
         {
             return m1.membre_classe2;
         }
         /* voir, pourquoi pas */
         void ModifyMembreClass2(/* const */ type /*&*/ newval)
         {
              m1.membre_classe2=newval;
         }
    private:
        Classe2 m1;
 
};

Tu pourras alors cr�er sans probl�me un objet de type Classe2

Code:

1
2
3
Classe1::Classe2 objet; /* aucun problème: le constructeur de
                          * Classe2 est public
                          */

mais le seul moyen de modifier la valeur de membre_classe2 passera par l'utilisation d'un objet de type Classe1

Code:

1
2
3
4
5
6
7
8
9
 
/* aucun acces à objet.membre_classe2, car il est privé ...
 * par contre tu peux y accéder par Classe1
 */
Classe1 autre_objet;
/* pour récupérer la valeur */
type val=autre_objet.GetMembreClass2();
/* ou pour en changer la valeur */
autre_objet.ModifyMembreClass2(la_nouvelle_valeur);

02/11/2007, 12h52
koala01
Citation:

Envoy� par LePetitBricoleur

d�sol� Alp mais franchement je suis un debutant j'ai rien compris � la 2)
c'est quoi un couple accesseur/mutateur?

merci

Accesseur et mutateur ne sont que des m�thodes (publiques) pour lesquelles on pr�cise ce qu'elles sont sens�es faire:
- un accesseur va permettre d'obtenir une valeur (les fameuses m�thodes GetMembre() et GetMembreClass2() de mes exemples)
- un mutateur va permettre de... modifier la valeur d'un membre (les fameuses m�thodes SetMembre() et ModifyMembreClass2() de mes exemples)
En anglais, on parle souvent de "getters" et de "setters" :D:P
02/11/2007, 12h56
LePetitBricoleur

classes imbriqu�es probleme

En fait le truc c'est que dans la classe 1 pour la methode Method_classe1
j'aimerais pouvoir modifier la valeur de Membre_classe2

void classe1::Method_classe1()
{
Membre_classe1=.... ;
}

comment faire pour pouvoir avoir acc�s � Membre_classe2 � l'interieur de Method_classe1
02/11/2007, 13h03
LePetitBricoleur

probl�me classe imbriqu�es

ok! je crois avoir compris
Tout a l'heure mon dernier message a �t� envoy� avant de lire vos reponses
Je vous remercie beaucoup pour cette aide
02/11/2007, 13h07
koala01
En suivant les exemples que j'ai fournis :D

En fait, il y a deux solutions encore:
1. Soit la Classe1 dispose d'un membre de type Classe2, et ce sont les exemples fournis
2. Soit, la Classe1 n'a pas de membre de type Classe2, et il s'agira alors de fournir un objet de type Classe2 comme param�tre (r�f�rence constante si lecture seule, r�f�rence non constante si tentative de modification)
Mais, quoi qu'il en soit, il faudra passer par une intance de type Classe2, selon le cas:
- m1.GetMembre(),
- m1.SetMembre(valeur),
- m1.membre_classe2,
ou m1 est soit membre de la classe Classe1, soit parametre fournis � la m�thode
02/11/2007, 13h17
LePetitBricoleur

probl�me classes imbriqu�es

Mais bon...c'est pas vraiment la meme chose..l� dans les explications que vous m'avez donn� si j'ai bien compris il faut instancier les classe et utiliser des fonctions pour modifier ou setter les membres de classe 2.

moi ce que je veux faire c'est vraiment setter les membres de classe2 dans une methode de classe 1 (en gros dans le code de Method_class1 pouvoir � un moment dire membre_classe2 vaut ...)

suis-je alors obliger dans le code de Method_class1 d'instancier encore un objet class1? �a devient redondant non?
02/11/2007, 13h20
LePetitBricoleur

probl�mes classes imbriqu�es

ok! �a y est j'ai compris
d�sol� du message pr�c�dent j'avais pas tr�s bien compris...je viens de comprendre. En gros c'est tout con..il faut juste disposer d'un membre classe2 et ensuite hop hop

merci beaucoup

Non...

Si tu veux modifier la valeur de membre_classe2 dans Classe1, il faut:

que tu aies une instance de type Classe1 pour pouvoir appeler la m�thode (SetMembreClasse2()) (� moins que ce ne soit une m�thode statique, mais on ne va pas t'embrouiller d'avantage avec cela :D)
au choix

Soit que la classe Classe1 dispose d'un membre de type de Classe2
Soit fournir une r�f�rence de type Classe2 comme param�tre � la m�thode (SetCMembreClasse2())

O� est la redondance, l� dedans :question:

Ou, plut�t, que ne comprend tu pas dans l'id�e :question:

Ainsi, en reprenant l'exemple o� seul Classe1 doit pouvoir acc�der au membre de Classe2, mais en l'adaptant pour que Classe1 n'aient pas de membre de type de Classe2, cela deviendrait:
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 class Classe1 { public: class Classe2 { public: Classe2();//constructeur ~Classe2();//destructeur /* pas d'acces à membre_classe2, car aucun mutateur/accesseur*/ private: type membre_classe2; /* sauf pour Classe1, parce qu'elle est déclarée amie */ friend class Classe1; }; Classe1(); ~Classe1(); /* modifier la valeur */ void SetClasse2Member( Classe2& mod, /*const*/ type /*&*/ newval) { mod.membre_classe2=newval; } /* récupérer la valeur */ /*const*/ type/*&*/GetClass2Member(const Classe2& toget) const { return toget.membre_classe2; } };
L'utilisation en deviendrait
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 /* Création d'un objet de type Classe2 */ Classe2 obj; /* on n'a aucun acces à obj.membre_classe2, donc il nous faut un objet * de type Classe1 pour y arriver */ Classe1 hasaccess; /* au travers de hasaccess, on peut maintenant accéder à * obj.membre_classe2 * * Soit pour en obtenir la valeur */ type recup=hasaccess.GetClass2Member(obj); /* soit pour la modifier */ hasaccess.SetClass2Member(obj, nouvelle_valeur_pour_membre_classe2);