Différence entre public, privé et protégé de l'héritage

De répondre à cette question, j'aimerais décrire membre du accesseurs en premier dans mes propres mots. Si vous le savez déjà, passez à la rubrique "suivant:".

Il y a trois accesseurs que je suis au courant: public, protected et private.

Laisser:

class Base {
    public:
        int publicMember;
    protected:
        int protectedMember;
    private:
        int privateMember;
};

• Tout ce qui est conscient de Base est également conscient du fait que Base contient publicMember.
• Seulement les enfants (et leurs enfants) sont conscients que Base contient protectedMember.
• Pas un, mais Base est conscient de privateMember.

Par "est au courant de", je veux dire "reconnaître l'existence d', et ainsi être en mesure d'accéder à".

suivante:

La même chose arrive avec le public, le privé et protégé de l'héritage. Considérons une classe Base et une classe Child qui hérite de Base.

• Si l'héritage est public, tout ce qui est conscient de Base et Child est également conscient du fait que Child hérite de Base.
• Si l'héritage est protected, seulement Child, et ses enfants sont conscients qu'ils héritent de Base.
• Si l'héritage est private, personne d'autre que Child est conscient de l'héritage.

Limiter la visibilité de la succession dont le code est pas capable de voir qu'une classe hérite d'une autre classe: les conversions Implicites de la dérivée de la base ne fonctionne pas, et static_cast à partir de la base de la dérivée ne fonctionne pas, soit.

Seuls les membres/amis d'une classe peut voir privé de l'héritage, et seuls les membres/amis et les classes dérivées peuvent voir les protégés de l'héritage.

public héritage

1. EST-UN héritage. Un bouton-une fenêtre, et partout où une fenêtre est nécessaire, un bouton peut être passé trop.

   class button : public window { };

protégé héritage

1. Protégés mis en œuvre-en-termes-de. Rarement utile. Utilisé dans boost::compressed_pair de dériver de vide de classes et d'économiser de la mémoire à l'aide de vide de la classe de base de l'optimisation (exemple ci-dessous n'utilise pas de modèle de continuer à être au point):

   struct empty_pair_impl : protected empty_class_1 
   { non_empty_class_2 second; };
   
   struct pair : private empty_pair_impl {
     non_empty_class_2 &second() {
       return this->second;
     }
   
     empty_class_1 &first() {
       return *this; //notice we return *this!
     }
   };

privé héritage

1. Mis en œuvre-en-termes-de. L'utilisation de la classe de base est uniquement pour la mise en œuvre de la classe dérivée. Utile avec les traits et si les sujets de taille (vide traits qui ne contiennent que des fonctions de faire usage de la vide de la classe de base de l'optimisation). Souvent de confinement est la meilleure solution. La taille des chaînes est critique, il est donc souvent vu usage ici

   template<typename StorageModel>
   struct string : private StorageModel {
   public:
     void realloc() {
       //uses inherited function
       StorageModel::realloc();
     }
   };

---

public membre

1. Globale

   class pair {
   public:
     First first;
     Second second;
   };

2. Accesseurs

   class window {
   public:
       int getWidth() const;
   };

protégé membre

1. L'amélioration de l'accès pour les classes dérivées

   class stack {
   protected:
     vector<element> c;
   };
   
   class window {
   protected:
     void registerClass(window_descriptor w);
   };

privé membre

1. Garder les détails de mise en œuvre

   class window {
   private:
     int width;
   };

---

Noter que les C-style jette délibérément permet de lancer une classe dérivée d'une protected ou private de la classe de base dans une manière sûre et à jeter dans l'autre sens aussi. Cela doit être évité à tous les frais, car il peut rendre le code dépend de détails de mise en œuvre - mais si nécessaire, vous pouvez faire usage de cette technique.

Ces trois mots-clés sont également utilisés dans un contexte totalement différent de spécifier le visibilité modèle d'héritage.

Ce tableau regroupe toutes les combinaisons possibles de la composante de la déclaration et de l'héritage du modèle de présentation de l'résultant de l'accès aux composants lorsque le sous-classe est complètement défini.

Le tableau ci-dessus est interprété de la manière suivante (jetez un oeil à la première ligne):

si un composant est déclaré comme public et sa classe est hérité comme public l'résultant accès est public.

Un exemple:

 class Super {
    public:      int p;
    private:     int q;
    protected:   int r;
 };

 class Sub : private Super {};

 class Subsub : public Sub {};

L'résultant de l'accès pour les variables p, q, r dans la classe Subsub est aucun.

Un autre exemple:

class Super {
    private:     int x;
    protected:   int y;
    public:      int z;
 };
class Sub : protected Super {};

L'résultant de l'accès pour les variables y, z dans la classe Sous est protégé et pour la variable x est aucun.

Un exemple plus détaillé:

class Super {
private:
    int storage;
public:
    void put(int val) { storage = val;  }
    int  get(void)    { return storage; }
};
int main(void) {
    Super object;

    object.put(100);
    object.put(object.get());
    cout << object.get() << endl;
    return 0;
}

Maintenant permet de définir une sous-classe:

class Sub : Super { };

int main(void) {
    Sub object;

    object.put(100);
    object.put(object.get());
    cout << object.get() << endl;
    return 0;
}

De la catégorie définie nommé Sous laquelle est une sous-classe de la classe nommée Super ou que Sub classe est dérivée de la Super classe.
Le Sub classe introduit ni de nouvelles variables, ni de nouvelles fonctions. Ça veut dire que n'importe quel objet de la Sub classe hérite de toutes les caractéristiques après la Super la classe qui est en fait une copie d'un Super de la classe des objets?

Pas. Il n'a pas.

Si nous compiler le code suivant, nous n'obtiendrez rien, mais des erreurs de compilation en disant que put et get méthodes sont inaccessibles. Pourquoi?

Lorsque nous omettons la visibilité prescripteur, le compilateur suppose que nous allons appliquer la soi-disant privé de l'héritage. Cela signifie que tous les public superclasse composants transformer en privé accès, privé de la superclasse des composants ne sera pas accessible à tous. Cela signifie donc que vous n'êtes pas autorisé à utiliser ce dernier à l'intérieur de la sous-classe.

Nous informer le compilateur que nous voulons préserver la politique d'accès.

class Sub : public Super { };

Ne pas être induit en erreur: cela ne signifie pas que les éléments privés de la Super
classe (comme le stockage variable) va se transformer en public, dans un
un peu de magie. Privé composantes restent privé, public
restera public.

Objets de la Sub classe peut faire "presque" les mêmes choses que leurs frères et sœurs plus âgés créé à partir de la Super classe. "Presque" parce que le fait d'être une sous-classe signifie également que le classe perdu l'accès privé pour les composants de la super-classe. On ne peut pas écrire une fonction membre de la Sub classe qui serait capable de manipuler directement le stockage variable.

C'est une très grave restriction. Est-il une solution de contournement?

Oui.

Le troisième niveau d'accès est appelé protégé. Le mot-clé protégé signifie que le composant marqué avec elle se comporte comme un établissement public lorsqu'il est utilisé par aucune des sous-classes et ressemble à un privé pour le reste du monde. -- C'est vrai que pour le public hérité de classes (comme la Super-classe dans notre exemple) --

class Super {
protected:
    int storage;
public:
    void put(int val) { storage = val;  }
    int  get(void)    { return storage; }
};

class Sub : public Super {
public:
    void print(void) {cout << "storage = " << storage;}
};

int main(void) {
    Sub object;

    object.put(100);
    object.put(object.get() + 1);
    object.print();
    return 0;
}

Comme vous le voyez dans l'exemple de code que nous avons une nouvelle fonctionnalité à l' Sub classe et il fait une chose importante: il accède à la variable de la classe Super.

Il ne serait pas possible si la variable a été déclarée à titre privé.
Dans la fonction principale de la portée de la variable qui reste caché de toute façon donc si vous écrivez quelque chose comme:

object.storage = 0;

Le compilateur va vous informer qu'il est un error: 'int Super::storage' is protected.

Enfin, le dernier programme produira la sortie suivante:

storage = 101

1) Patrimoine Public:

un. Les membres privés de la classe de Base ne sont pas accessibles dans la classe Dérivée.

b. Des membres protégés de la classe de Base restent protégés dans la classe Dérivée.

c. Les membres publics de la classe de Base restent dans le domaine public dans la classe Dérivée.

Ainsi, d'autres classes peuvent utiliser les membres publics de la classe de Base par le biais objet de classe Dérivée.

2), À L'Abri De L'Héritage:

un. Les membres privés de la classe de Base ne sont pas accessibles dans la classe Dérivée.

b. Des membres protégés de la classe de Base restent protégés dans la classe Dérivée.

c. Les membres publics de la classe de Base deviennent les membres protégés de la classe Dérivée.

Donc, les autres classes ne peuvent pas utiliser les membres publics de la classe de Base par le biais de Dérivés de la classe de l'objet; mais ils sont disponibles à la sous-classe des Dérivés.

3) Privé De L'Héritage:

un. Les membres privés de la classe de Base ne sont pas accessibles dans la classe Dérivée.

b. Protégé & les membres publics de la classe de Base deviennent des membres privés de la classe Dérivée.

Ainsi, aucun des membres de la classe de Base peut être consulté par d'autres classes, par objet de classe Dérivée comme ils sont privés dans la classe Dérivée. Donc, même sous-classe de la Dérivée
la classe ne peuvent pas y accéder.

Si vous héritez d'un public d'une autre classe, tout le monde sait que vous êtes héritent et vous pouvez être utilisé polymorphically par une personne au moyen d'une base de pointeur de classe.

Si vous héritez protectedly seulement vos enfants des classes sera capable de l'utiliser vous polymorphically.

Si vous héritez en privé seulement vous serez en mesure d'exécuter les méthodes de la classe parent.

Qui, fondamentalement, symbolise la connaissance du reste de la classe au sujet de votre relation avec votre classe parent

Résumé:

• Privé: personne ne peut le voir, sauf à l'intérieur de la classe
• Protégé: Privé + les classes dérivées peuvent voir
• Public: le monde peut le voir

Lorsque vous héritez, vous pouvez (dans certaines langues) changer le type de protection d'un membre de données dans certaine direction, par exemple, de protection du public.

Privé:

Les membres privés d'une classe de base ne peut être accessible que par les membres de la classe de base .

Public:

Le public et les membres d'une classe de base peut être consulté par les membres de la classe de base, les membres de sa classe dérivée ainsi que les membres qui sont en dehors de la classe de base et la classe dérivée.

Protégé:

Les membres protégés de la classe de base peut être consulté par les membres de la classe de base ainsi que les membres de sa classe dérivée.

---

En bref:

privé: base

protégé: base + dérivés

public: base + dérivé + tout autre membre

C'est essentiellement la protection de l'accès du public et des membres protégés de la classe de base dans la classe dérivée. Avec le service public de l'héritage, la classe dérivée peut voir le public et les membres protégés de la base. Avec privé de l'héritage, il ne peut pas. Protégée, la classe dérivée et de toutes les classes dérivées de qui peut les voir.