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

ce sont des Spécificateurs d'Accès?

Il y a 3 access specifiers pour un class/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, tout membre d'une classe est accessible à l'intérieur de cette classe(à l'Intérieur de toute fonction membre de la même classe). Aller de l'avant pour le type de spécificateurs d'accès, ils sont:

Public - Les membres déclarée Public sont accessibles depuis l'extérieur de la Classe par le biais d'un objet de la classe.

Protégé - Les membres déclarée Protégée sont accessibles à partir de l'extérieur de la classe MAIS seulement dans une classe dérivée.

Privé - Ces membres sont uniquement accessibles à partir de l'intérieur de 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
}

---

L'héritage et les Spécificateurs d'Accès

L'héritage en C++ peut être un des types suivants:

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

Ici sont les règles d'accès à l'égard de chacune de ces:

Première et la plus importante règle Private les membres d'une catégorie ne sont jamais accessibles à partir de n'importe où, sauf les membres de la même classe.

Patrimoine Public:

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

Tous les Protected membres de la Classe de Base deviennent Protected Membres de la Classe Dérivée.

c'est à dire Pas de changement dans l'Accès des membres. Les règles d'accès, nous avons discuté avant sont ensuite appliqués à 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

}

Privé De L'Héritage:

Tous Public membres de la Classe de Base deviennent Private Membres de la classe Dérivée &

Tous les Protected 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

}

Protégé De L'Héritage:

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

Tous les Protected membres de la Classe de Base deviennent Protected Membres de la Classe Dérivée.

Un 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 les mêmes règles d'accès s'appliquent pour les classes et les membres en bas de la hiérarchie d'héritage.

---

Points importants à noter:

- Spécification d'accès est par Catégorie et non par l'Objet

Noter que la spécification d'accès C++ de travail sur la fonction de la Classe et non pas par objet.

Un bon exemple de ceci est que dans un constructeur de copie ou Copie de l'opérateur d'Assignation de fonction, tous les membres de l'objet est transmis peut être consulté.

- Une classe Dérivée peut accéder uniquement aux membres de sa propre classe de Base

Envisager la 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 propres de Base de Catégorie. Notez que l'objet obj d'être passé ici est en aucune façon liée à la derived fonction de classe dans lequel il est accessible, c'est une toute autre objet, et donc derived fonction membre ne peut pas accéder à ses membres.

---

Qu'est ce qu'un friend? Comment friend une incidence sur l'accès spécification de règles?

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

Donc, ne friends briser l'Encapsulation?

Non, ils ne le font pas, au contraire ils permettent de renforcer l'Encapsulation!

friendnavire est utilisé pour indiquer un intentionnelle de couplage fort entre les deux entités.

S'il existe une relation spéciale entre les deux entités, telles que l'on a besoin d'accéder à d'autres private ou protected membres, mais Vous ne voulez pas tout le monde d'avoir accès à l'aide de la public spécificateur d'accès alors vous devriez utiliser friendnavire.