Hériter des membres privés en C ++

supposons qu'une classe a données privées des membres de mais les setters et getters sont à portée publique. Si vous hériter de cette classe, vous pouvez toujours appeler les setters et getters -- en permettant l'accès aux données privées des membres de la classe de base. Comment est-ce possible puisqu'il est mentionné qu'une classe dérivée ne peut pas hériter des données privées des membres de la

source d'informationauteur shreyasva

  1. 23

    Une classe dérivée n'a pas hérité de accès aux données privées des membres. Toutefois, il ne hériter d'un parent complet de l'objet, qui contient l'un des membres privés dont cette classe déclare.

  2. 6

    Il dépend de l'héritage de type. Si vous héritez en privé, puis la classe dérivée n'a PAS accès à la Base de membres privés.

    Access                      public     protected    private
-----------------------------------------------------------
members of the same class      yes           yes        yes
members of derived classes     yes           yes         no
not members                    yes            no         no
  3. 4

    Parce que les getters et les setters sont public -- ils sont rachetables par tous, et pas seulement les classes dérivées.

  4. 1

    vous pouvez accéder par l'accès à des setters et getters public et l'acces à ce 

    *.h
class Mamifere
{
private:
int a;
public:
Mamifere();
virtual ~Mamifere();
int getA();
//~Mamifere(); //le delete dans le exp02() affiche seulement mamifere mort :( destructeur de la class mere 
void manger() ;
virtual void avancer() const;
};
class Deufin:public Mamifere{
public:
Deufin();
void manger() const;
void avancer() const;
~Deufin();
};
*.cpp
Mamifere::Mamifere(){
printf("nouveau mamifere est nee\n");
this->a=6;
}
Mamifere::~Mamifere(){
printf("mamifere Mort :(\n");
}
void Mamifere::manger() {
printf("hhhh   je mange maifere %d\n",Mamifere::getA());
}
void Mamifere::avancer() const{
printf("allez-y Mamifere\n");
}
Deufin::Deufin(){
printf("nouveau Deufin  est nee\n");
}
int Mamifere::getA(){
return this->a;
}
void Deufin::manger() const{
printf("hhhh   je mange poisson\n");
}
void Deufin::avancer() const{
printf("allez-y Deufin\n");
}
Deufin::~Deufin(){
printf("Deufin Mort :(\n");
}
main.cpp
void exp031(){
Mamifere f;//nouveau mamifere est nee   //  nouveau Deufin  est nee
Deufin d;
f.avancer();//allez-y Deufin (resolution dynamique des lien  la presence de mot cle virtual)
f.manger();//hhhh   je mange maifere (resolution static des lien pas de mot cle virtual)
printf("a=%d\n",d.getA());//Deufin Mort :(   mamifere Mort :( (resolution static des lien  la presence de mot cle virtual) distructeur de class fille appel auromatiquement le destructeur de la class mere
}
int main(){
exp031();
getchar();
return 0;
}
  5. 0

    Getters et setters ne Pas vous donner un contrôle complet sur les données privées des membres. Le contrôle est toujours la classe de base.

  6. 0

    À l'aide du modèle

    class MyClass {
private: int a;
public: void setA(int x) { a = x; }
public: int getA() const { return a; }
};

    semble orientée objet et a l'envoyé de l'encapsulation.

    Cependant comme vous l'avez remarqué, vous pouvez toujours accéder directement au domaine privé et il n'y a rien de gagné plus juste de faire a public, et y accéder directement.

    À l'aide des getters et setters comme cela n'a pas vraiment de sens en C++.

  7. 0

    Ils sont inclus, mais pas héréditaire. Ce que cela signifie, c'est:

    • Tout d'hériter de type (: public SomeClass: protected SomeClass ou même : SomeClasséquivalent à : private SomeClass) pas les rendre accessibles à partir de l'enfant méthodes de la classe, ou à l'extérieur (this->a et someobject.a respectivement);
    • Ils ne seront toujours "être là" - prendre l'espace dans la mémoire allouée pour les enfants de la classe de l'instance;
    • Les méthodes héritées sera capable d'accéder à la zone privée.

    Donc, en gros, protected n'est pas visible à l'extérieur tandis que l'intérieur visible et de classes dérivées (si : private Parent n'a pas été utilisé), tandis que private n'est pas visible ni de classes dérivées, ni à l'extérieur de la classe parent; il n'est visible que pour les parents de la classe de méthodes, même si elles sont héritées (mais pas surdéfini).