Quelles sont les spécificateurs d'accès? Dois-je hériter avec privé, protégé ou public?

qu'est-ce que les spécificateurs D'accès?

il y en a 3 access specifiers pour une classe / struct / Union en C++. Ces spécificateurs d'accès définir la façon dont les membres de la classe peuvent être accessibles. Bien sûr, n'importe quel membre d'une classe est accessible dans cette classe(à l'intérieur de n'importe quelle fonction de membre de cette même classe). En ce qui concerne les spécificateurs d'accès, ils sont:

Public - les membres déclarés publics sont accessibles de l'extérieur de la classe par un objet de la classe.

protégé - les membres déclarés protégés sont accessibles de l'extérieur de la classe mais seulement dans une classe dérivée.

Privé - ces membres ne sont accessibles que dans la classe. Aucun Accès à l'extérieur est autorisé.

Un Exemple De Code Source:

class MyClass
{
    public:
        int a;
    protected:
        int b;
    private:
        int c;
};

int main()
{
    MyClass obj;
    obj.a = 10;     //Allowed
    obj.b = 20;     //Not Allowed, gives compiler error
    obj.c = 30;     //Not Allowed, gives compiler error
}

---

spécificateurs D'héritage et D'accès

l'Héritage en C++ peut être l'un des les types suivants:

• Private Héritage
• Public Héritage
• Protected héritage

Voici les règles d'accès des membres pour chacun d'eux:

première et plus importante règle Private les membres d'une classe ne sont jamais accessibles de n'importe où sauf les membres de la même classe classe.

Héritage Public:

Public les membres de la Classe de Base deviennent Public membres de la classe dérivée &

Tous les Protected les membres de la Classe de Base deviennent Protected membres de la classe dérivée.

c.-à-d. aucun changement dans l'accès des membres. Les règles d'accès dont nous avons parlé précédemment sont ensuite appliquées à ces membres.

Exemple De Code:

Class Base
{
    public:
        int a;
    protected:
        int b;
    private:
        int c;
};

class Derived:public Base
{
    void doSomething()
    {
        a = 10;  //Allowed 
        b = 20;  //Allowed
        c = 30;  //Not Allowed, Compiler Error
    }
};

int main()
{
    Derived obj;
    obj.a = 10;  //Allowed
    obj.b = 20;  //Not Allowed, Compiler Error
    obj.c = 30;  //Not Allowed, Compiler Error

}

Héritage Privé:

Public les membres de la Classe de Base deviennent Private membres de la classe dérivée &

Tous les Protected les membres de la Classe de Base deviennent Private membres de la classe dérivée.

un exemple de code:

Class Base
{
    public:
      int a;
    protected:
      int b;
    private:
      int c;
};

class Derived:private Base   //Not mentioning private is OK because for classes it  defaults to private 
{
    void doSomething()
    {
        a = 10;  //Allowed 
        b = 20;  //Allowed
        c = 30;  //Not Allowed, Compiler Error
    }
};

class Derived2:public Derived
{
    void doSomethingMore()
    {
        a = 10;  //Not Allowed, Compiler Error, a is private member of Derived now
        b = 20;  //Not Allowed, Compiler Error, b is private member of Derived now
        c = 30;  //Not Allowed, Compiler Error
    }
};

int main()
{
    Derived obj;
    obj.a = 10;  //Not Allowed, Compiler Error
    obj.b = 20;  //Not Allowed, Compiler Error
    obj.c = 30;  //Not Allowed, Compiler Error

}

Héritage Protégé:

Public les membres de la Classe de Base deviennent Protected membres de la classe dérivée &

Tous les Protected les membres de la Classe de Base deviennent Protected membres de la classe dérivée.

Exemple De Code:

Class Base
{
    public:
        int a;
    protected:
        int b;
    private:
        int c;
};

class Derived:protected Base  
{
    void doSomething()
    {
        a = 10;  //Allowed 
        b = 20;  //Allowed
        c = 30;  //Not Allowed, Compiler Error
    }
};

class Derived2:public Derived
{
    void doSomethingMore()
    {
        a = 10;  //Allowed, a is protected member inside Derived & Derived2 is public derivation from Derived, a is now protected member of Derived2
        b = 20;  //Allowed, b is protected member inside Derived & Derived2 is public derivation from Derived, b is now protected member of Derived2
        c = 30;  //Not Allowed, Compiler Error
    }
};

int main()
{
    Derived obj;
    obj.a = 10;  //Not Allowed, Compiler Error
    obj.b = 20;  //Not Allowed, Compiler Error
    obj.c = 30;  //Not Allowed, Compiler Error
}

rappelez-vous que les mêmes règles d'accès s'appliquent aux classes et aux membres de la hiérarchie de l'héritage.

---

points Importants à noter:

- la spécification D'accès est par classe et non par objet

Notez que l'accès spécification c++ travail par classe et non par objet.

Un bon exemple de ceci est que dans une fonction de constructeur de copie ou d'opérateur D'affectation de copie, tous les membres de l'objet passé peuvent être consultés.

- une classe dérivée ne peut accéder qu'aux membres de sa propre classe de Base

Considérer l' exemple de code suivant:

class Myclass
{ 
    protected: 
       int x; 
}; 

class derived : public Myclass
{
    public: 
        void f( Myclass& obj ) 
        { 
            obj.x = 5; 
        } 
};

int main()
{
    return 0;
}

Il donne une erreur de compilation:

prog.rpc:4: erreur: ‘int Maclasse::x’ est protégé

Parce que la classe dérivée ne peut accéder aux membres de son propre classe de Base. Notez que l'objet obj passer ici n'a rien à voir avec le derived fonction de classe dans laquelle il est accédé, il est un objet tout à fait différent et donc derived fonction membre ne peut pas accéder à son membre.

---

qu'est Ce qu'un friend? Comment fonctionne friend affecter les règles de spécification d'accès?

Vous pouvez déclarer une fonction ou une classe friend d'une autre classe. Lorsque vous le faites, les règles de spécification d'accès ne s'appliquent pas à friended de classe/fonction. La classe ou la fonction peut accéder à tous les membres de cette classe particulière.

Donc, ne friends pause L'Encapsulation?

non ils ne le font pas, au contraire ils améliorent L'Encapsulation!

friendnavire est utilisé pour indiquer un couplage fort intentionnel entre deux entités.

S'il existe une relation spéciale entre deux entités telle que l'une doit avoir accès à d'autres private ou protected membres, mais Vous ne voulez pas tout le monde d'y accéder en utilisant public spécifiez l'accès alors vous devez utiliser friendnavire.