C++ Zugriffsmodifikatoren für Klassen

C++ Klassen und Objekte

In der objektorientierten Programmierung (OOP) in C++ ist die Datenkapselung eines der Kernkonzepte. Einfach ausgedrückt bedeutet sie, die Daten zu „verbergen“ und nur die notwendigen Schnittstellen nach außen freizugeben, um die Datensicherheit zu gewährleisten.

Um zu steuern, wer diese Daten sehen kann, stellt C++ drei Schlüsselwörter bereit, die alsZugriffsmodifikatoren bezeichnet werden：

  • public(public)
  • private(private)
  • protected(protected)
class Base { public: //Öffentliche Member protected: // Geschützte Mitglieder private: // Private Mitglieder };

Zum besseren Verständnis können wir uns eineKlasse als Ihr Zuhause vorstellen：

Modifizierer Analogie aus der realen Welt Wer hat Zugriff? Typische Verwendung
public Wohnzimmer/Haustür Alle(innerhalb der Klasse, Unterklassen, externer Code) Schnittstellenfunktionen (API), die der Außenwelt bereitgestellt werden.
protected Schlafzimmer Sie und Ihre Kinder(innerhalb der Klasse, Unterklassen) Daten, die nur innerhalb der Familie verwendet werden (Vererbungshierarchie).
private Sicher Nur Sie selbst(nur innerhalb der Klasse selbst) Kerndaten, Variablen, die nicht leichtfertig geändert werden sollten.

Hinweis: Wenn kein Modifizierer geschrieben wird, sind C++-Klassenmemberstandardmäßigprivate(private).

public-Member

public-Member sind überall im Programm zugänglich, ohne sie über Memberfunktionen lesen oder schreiben zu müssen, wie im folgenden Beispiel gezeigt:

Beispiel

#include <iostream> using namespace std; class Line { public: double length; void setLength( double len ); double getLength( void ); }; // Definition der Memberfunktion double Line::getLength(void) { return length ; } void Line::setLength( double len ) { length = len; } // Die Hauptfunktion des Programms int main( ) { Line line; // Länge setzen line.setLength(6.0); cout << "Länge der Linie : " << line.getLength() <<endl; // Länge setzen, ohne eine Memberfunktion zu verwenden line.length = 10.0; // OK: weil length öffentlich ist cout << "Länge der Linie : " << line.length <<endl; return 0; }

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Length of line : 6
Length of line : 10

private Member

Private Member sind gegenüber der Außenwelt der Klasse vollständig abgeschirmt; externer Code kann sie nicht lesen, ändern oder aufrufen, und abgeleitete Klassen haben ebenfalls keine direkten Zugriffsrechte. Nur die eigenen Memberfunktionen der Klasse und Entitäten, denen Friend-Berechtigung gewährt wurde, können auf diese Inhalte zugreifen.

Wenn in der Klasse kein Zugriffsspezifizierer verwendet wird, sind Member standardmäßig private. Wie im folgenden Beispiel gezeigt, fällt width automatisch in den privaten Bereich, was bedeutet, dass nicht explizit gekennzeichnete Member alle als private behandelt werden:

Beispiel

class Box { double width; public: double length; void setWidth( double wid ); double getWidth( void ); };

In der Praxis definieren wir Daten üblicherweise im private-Bereich und definieren zugehörige Funktionen im public-Bereich, sodass diese Funktionen auch außerhalb der Klasse aufgerufen werden können, wie unten gezeigt:

Beispiel

#include <iostream> using namespace std; class Box { public: double length; void setWidth( double wid ); double getWidth( void ); private: double width; }; // Definition der Memberfunktion double Box::getWidth(void) { return width ; } void Box::setWidth( double wid ) { width = wid; } // Die Hauptfunktion des Programms int main( ) { Box box; // Länge setzen, ohne eine Memberfunktion zu verwenden box.length = 10.0; // OK: weil length public ist cout << "Länge der Box : " << box.length <<endl; // Breite ohne Verwendung einer Memberfunktion festlegen // box.width = 10.0; // Fehler: weil width privat ist box.setWidth(10.0); // Breite mit einer Memberfunktion festlegen cout << "Breite von box : " << box.getWidth() <<endl; return 0; }

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Length of box : 10
Width of box : 10

protected Member

protectedDie Existenz von ... dient hauptsächlich derVererbung。

  • Wenn es keine Vererbung gibt, es undprivatedasselbe (für Außenstehende nicht sichtbar).
  • Wenn es Vererbung gibt,kann eine Unterklasse (abgeleitete Klasse) auf dasprotectedMemberder Elternklasse zugreifen, aber nicht aufprivateMember.

Im nächsten Kapitel lernst du etwas über abgeleitete Klassen und Vererbung. Jetzt kannst du im folgenden Beispiel sehen, dass wir von der ElternklasseBoxeine UnterklassesmallBox abgeleitet haben。

Das folgende Beispiel ähnelt dem vorherigen Beispiel; hierwidthMember sind für jede Memberfunktion der abgeleiteten Klasse smallBox zugänglich.

Beispiel

#include <iostream> using namespace std; class Box { protected: double width; }; class SmallBox:Box // SmallBox ist eine abgeleitete Klasse { public: void setSmallWidth( double wid ); double getSmallWidth( void ); }; // Memberfunktion der abgeleiteten Klasse double SmallBox::getSmallWidth(void) { return width ; } void SmallBox::setSmallWidth( double wid ) { width = wid; } // Die Hauptfunktion des Programms int main( ) { SmallBox box; // Breite mit einer Memberfunktion festlegen box.setSmallWidth(5.0); cout << "Breite der Box : "<< box.getSmallWidth() << endl; return 0; }

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Width of box : 5

Änderungen der Zugriffsrechte bei Vererbung

Wenn Sie eine Unterklasse definieren (wie z. B.class B : public A), nach dem Doppelpunktpublicist ebenfalls ein Zugriffsmodifizierer; er bestimmtWie die Mitglieder der Elternklasse in der Kindklasse "erscheinen"。

Das sieht kompliziert aus, aber Sie müssen sich nur diesesHerabstufungsprinzip merken：

Die Vererbungsart bestimmt die höchste Berechtigung, die Mitglieder der Elternklasse in der Kindklasse haben.
Wenn die Vererbungsart strenger ist als die ursprüngliche Berechtigung des Mitglieds, wird die Berechtigung des Mitglieds auf die Ebene der Vererbungsart "herabgestuft".

Tabelle der Zugriffsänderungen

die ursprünglichen Zugriffsrechte der Mitglieder der Basisklasse public-Vererbung(am häufigsten verwendet) protected-Vererbung private-Vererbung
public bleiben public zu protected herabgestuft auf private herabgestuft
protected bleiben protected bleiben protected auf private herabgestuft
private Nicht zugänglich Nicht zugänglich Nicht zugänglich

Hinweis: Nicht zugänglich bedeutet, dass der Code der Kindklasse die Variable nicht direkt verwenden kann, aber die Variable weiterhin im Speicher existiert.

umfassender Demonstrationscode

Zur Verdeutlichung benennen wir die Variable um inpub_var(public),pro_var(protected),pri_var(private).

Beispiel

#include <iostream>
using namespace std;

class Parent {
public:
    int pub_var;
protected:
    int pro_var;
private:
    int pri_var; // Nur Parent selbst kann darauf zugreifen

public:
    Parent() { pub_var = 1; pro_var = 2; pri_var = 3; }
};

// 1. Öffentliche Vererbung – am häufigsten, originalgetreu
class ChildA : public Parent {
public:
    void test() {
        cout << pub_var << endl; // OK
        cout << pro_var << endl; // OK
        // cout << pri_var << endl; // Fehler! Private Mitglieder der Parent-Klasse sind nicht sichtbar
    }
};

// 2. Geschützte Vererbung – alles wird protected
class ChildB : protected Parent {
public:
    void test() {
        cout << pub_var << endl; // OK, aber aus Sicht von ChildB ist es protected
        cout << pro_var << endl; // OK
    }
};

// 3. 私有继承 - 所有成员都变为 private
class ChildC : private Parent {
public:
    void test() {
        cout << pub_var << endl; // 可以，但从 ChildC 的角度看，它是 private
        cout << pro_var << endl; // 可以，但从 ChildC 的角度看，它是 private
    }
};

int main() {
    ChildA a;
    cout << a.pub_var << endl; // 可以，外部可访问
    // cout << a.pro_var << endl; // 错误，protected 在外部不可访问

    ChildB b;
    // cout << b.pub_var << endl; // 错误！因为它是 protected 继承，pub_var 在外部变为 protected

    ChildC c;
    // cout << c.pub_var << endl; // 错误！因为它是 private 继承，pub_var 在外部变为 private

    return 0;
}

Zusammenfassung

  • 公有: 任何人都可以使用它。用作接口（API）。
  • Privat: Nur die Klasse selbst kann es verwenden. Wird zum Speichern von Daten verwendet (sichere Standardoption).
  • Geschützt: Nur die Familie (Vererbungskette) kann es verwenden. Wird verwendet, um eine Hintertür für Kindklassen zu hinterlassen.

Vererbung:

  • Öffentliche Vererbung: Die Attribute der Elternklasse bleiben unverändert (am häufigsten verwendet).
  • Private/geschützte Vererbung: Verschärft die Berechtigungen von Mitgliedern der Elternklasse, wird normalerweise in speziellen Implementierungsszenarien verwendet.

C++ Klassen und Objekte

Weitere Erweiterungen