Discussion :

[LePetitBricoleur]

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?

[bolhrak]

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

[koala01]

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"

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

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 :

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

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

[LePetitBricoleur]

dans ce cas dans une structure de classe imbriquées:

Code :

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

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

[Alp]

Il te faut 1) une instance de la classe intérieure 2) un couple accesseur/mutateur pour ton attribut

[LePetitBricoleur]

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

merci

[koala01]

ou

1. une instance de la classe supérieure
2. 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 () qui prend la forme de

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

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

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 :

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

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

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 :

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

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