Was sind die Zugriffsbezeichner? Sollte ich Erben mit private, protected oder public?

was sind die Zugriffsbezeichner?

Gibt es 3 access specifiers für eine Klasse/Struktur/Union in C++. Diese Zugriffsbezeichner definieren, wie die Elemente der Klasse zugegriffen werden kann. Natürlich, jedes Mitglied einer Klasse zugegriffen werden kann, dass innerhalb dieser Klasse(Innerhalb einer member-Funktion der selben Klasse). Voran der Art der Zugriffsbezeichner, Sie sind:

Öffentlichen - Die member als Public deklariert sind, zugänglich von außerhalb der Klasse durch ein Objekt der Klasse.

Geschützt - Die Mitglieder, die als Protected deklariert sind, zugänglich von außerhalb der Klasse ABER nur eine Klasse davon abgeleitet.

Private - Diese Mitglieder sind der Zugriff nur von innerhalb der Klasse. Kein Zugriff von außen erlaubt ist.

Einen Source-Code Beispiel:

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
}

Erbschaft-und Zugriffsbezeichner

Vererbung in C++ kann eine der folgenden Arten:

• Private Vererbung
• Public Vererbung
• Protected Vererbung

Hier sind die access-Regeln mit Bezug auf jedes dieser:

Erste und wichtigste Regel Private Mitglieder einer Klasse sind nie von überall zugänglich, außer den Mitgliedern der gleichen Klasse.

Public-Vererbung:

Alle Public Mitglieder der Basisklasse werden Public Mitglieder der abgeleiteten Klasse &

Alle Protected Mitglieder der Basisklasse werden Protected Mitglieder der Abgeleiteten Klasse.

d.h. Keine Veränderung in der Zugang der Mitglieder. Die access-Regeln, die wir vorher besprochen werden weiter angewendet, um diese Mitglieder.

Code Beispiel:

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

}

Private-Vererbung:

Alle Public Mitglieder der Basisklasse werden Private Mitglieder der Abgeleiteten Klasse &

Alle Protected Mitglieder der Basisklasse werden Private Mitglieder der Abgeleiteten Klasse.

Einem code Beispiel:

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

}

Protected-Vererbung:

Alle Public Mitglieder der Basisklasse werden Protected Mitglieder der abgeleiteten Klasse &

Alle Protected Mitglieder der Basisklasse werden Protected Mitglieder der Abgeleiteten Klasse.

Einem Code-Beispiel:

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
}

Erinnern, den gleichen Zugang Regeln gelten für Klassen und member down der Vererbungshierarchie.

Wichtige Punkte zu beachten:

- Access-Spezifikation ist pro Klasse, nicht pro Objekt

Beachten Sie, dass die access-Spezifikation C++ arbeiten auf pro-Klasse basis und nicht pro-Objekt-basis.

Ein gutes Beispiel dafür ist, dass eine Kopier-Konstruktor oder Kopier-Zuweisung-operator-Funktion, die alle Elemente des Objekts übergeben werden kann zugegriffen werden.

- Eine Abgeleitete Klasse kann nur den Zugriff auf Mitglieder der eigenen Basisklasse

Betrachten die folgenden code Beispiel:

class Myclass
{ 
    protected: 
       int x; 
}; 

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

int main()
{
    return 0;
}

Gibt es einen compilation error:

prog.cpp:4: Fehler: "int Myclass::x' ist geschützt

Weil der abgeleiteten Klasse können nur auf die Mitglieder des eigene Basisklasse. Beachten Sie, dass das Objekt obj weitergegeben werden, hier ist keine Möglichkeit, im Zusammenhang mit der derived Klasse Funktion, in der es aufgerufen wird, es ist ein völlig anderes Objekt und somit derived member-Funktion zugreifen können seiner Mitglieder.

Was ist ein friend? Wie funktioniert friend Auswirkungen auf den Zugang der Spezifikation Regeln?

Können Sie deklarieren eine Funktion oder Klasse als friend einer anderen Klasse ist. Wenn Sie dies tun, der access-Spezifikation, die Regeln gelten nicht für die friended Klasse/Funktion. Die Klasse oder die Funktion kann auf alle Mitglieder der jeweiligen Klasse.

So tun friends Pause Kapselung?

Haben Sie nicht, im Gegenteil, Sie verbessern Kapselung!

friendSchiff wird verwendet, um anzuzeigen, dass ein vorsätzliche starke Kopplung zwischen zwei Entitäten.

Wenn es eine Besondere Beziehung zwischen zwei Entitäten solche, die einen Zugang zu anderen private oder protected Mitglieder, aber Sie nicht möchten, dass jeder Zugriff durch die Verwendung der public zugriffsspezifizierer dann sollten Sie friendSchiff.