C ++ - Zugriffsmodifikatoren

In diesem Tutorial lernen wir anhand von Beispielen die Zugriffsmodifikatoren für C ++ - Klassen kennen. Die Zugriffsmodifikatoren von C ++ sind öffentlich, privat und geschützt.

Eines der Hauptmerkmale objektorientierter Programmiersprachen wie C ++ ist das Ausblenden von Daten .

Das Ausblenden von Daten bezieht sich auf die Einschränkung des Zugriffs auf Datenelemente einer Klasse. Dies soll verhindern, dass andere Funktionen und Klassen die Klassendaten manipulieren.

Es ist jedoch auch wichtig, einige Elementfunktionen und Elementdaten zugänglich zu machen, damit die verborgenen Daten indirekt bearbeitet werden können.

Mit den Zugriffsmodifikatoren von C ++ können wir bestimmen, welche Klassenmitglieder für andere Klassen und Funktionen zugänglich sind und welche nicht.

Beispielsweise,

 class Patient ( private: int patientNumber; string diagnosis; public: void billing() ( // code ) void makeAppointment() ( // code ) );

Hier werden die Variablen patientNumber und Diagnose der PatientKlasse mit dem privateSchlüsselwort ausgeblendet , während die Elementfunktionen mit dem Schlüsselwort zugänglich gemacht werden public.

Arten von C ++ - Zugriffsmodifikatoren

In C ++ gibt es 3 Zugriffsmodifikatoren:

  • public
  • private
  • protected

Modifikator für öffentlichen Zugriff

  • Das publicSchlüsselwort wird verwendet, um öffentliche Mitglieder (Daten und Funktionen) zu erstellen.
  • Die öffentlichen Mitglieder sind von jedem Teil des Programms aus zugänglich.

Beispiel 1: C ++ public Access Modifier

 #include using namespace std; // define a class class Sample ( // public elements public: int age; void displayAge() ( cout << "Age = " << age << endl; ) ); int main() ( // declare a class object Sample obj1; cout <> obj1.age; // call class function obj1.displayAge(); return 0; )

Ausgabe:

 Geben Sie Ihr Alter ein: 20 Alter = 20

In diesem Programm haben wir eine Klasse mit dem Namen erstellt Sample, die ein publicvariables Alter und eine publicFunktion enthält displayAge().

In main()haben wir ein Objekt der SampleKlasse mit dem Namen obj1 erstellt. Wir greifen dann direkt auf die öffentlichen Elemente zu, indem wir die Codes obj.ageund verwenden obj.displayAge().

privater Zugriffsmodifikator

  • Das privateSchlüsselwort wird verwendet, um private Mitglieder (Daten und Funktionen) zu erstellen.
  • Auf die privaten Mitglieder kann nur innerhalb der Klasse zugegriffen werden.
  • Freundklassen und Freundfunktionen können jedoch auf private Mitglieder zugreifen.

Beispiel 2: C ++ Private Access Specifier

 #include using namespace std; // define a class class Sample ( // private elements private: int age; // public elements public: void displayAge(int a) ( age = a; cout << "Age = " << age << endl; ) ); int main() ( int ageInput; // declare an object Sample obj1; cout <> ageInput; // call function and pass ageInput as argument obj1.displayAge(ageInput); return 0; )

Ausgabe:

 Geben Sie Ihr Alter ein: 20 Alter = 20

In main()kann das Objekt obj1 nicht direkt auf die Klassenvariable age zugreifen.

 // error cin>> obj1.age;

Wir können das Alter nur indirekt über die öffentliche Funktion manipulieren displayAge(), da diese Funktion dem übergebenen Argument, dh dem Funktionsparameter, das Alter zuweist int a.

geschützter Zugriffsmodifikator

Bevor wir uns mit dem protectedZugriffsspezifizierer vertraut machen, stellen Sie sicher, dass Sie sich mit der Vererbung in C ++ auskennen.

  • Das protectedSchlüsselwort wird verwendet, um geschützte Mitglieder (Daten und Funktionen) zu erstellen.
  • Auf die geschützten Mitglieder kann innerhalb der Klasse und von der abgeleiteten Klasse aus zugegriffen werden.

Beispiel 3: C ++ geschützter Zugriffsspezifizierer

 #include using namespace std; // declare parent class class Sample ( // protected elements protected: int age; ); // declare child class class SampleChild : public Sample ( public: void displayAge(int a) ( age = a; cout << "Age = " << age << endl; ) ); int main() ( int ageInput; // declare object of child class SampleChild child; cout <> ageInput; // call child class function // pass ageInput as argument child.displayAge(ageInput); return 0; )

Ausgabe:

 Geben Sie Ihr Alter ein: 20 Alter = 20

Hier ChildSampleist eine geerbte Klasse, von der abgeleitet wird Sample. Das variable Alter wird Samplemit dem protectedSchlüsselwort deklariert.

Dies bedeutet, dass ChildSampleauf das Alter zugegriffen werden kann, da Samplees sich um die übergeordnete Klasse handelt.

Wir sehen dies, indem wir den Wert des Alters in zugewiesen haben ChildSample, obwohl das Alter in der SampleKlasse angegeben ist.

Zusammenfassung: öffentlich, privat und geschützt

  • public Auf Elemente kann von allen anderen Klassen und Funktionen zugegriffen werden.
  • privateAuf Elemente kann nur außerhalb der Klasse zugegriffen werden, in der sie deklariert sind, außer durch friendKlassen und Funktionen.
  • protectedElemente sind genau wie die private, außer dass abgeleitete Klassen auf sie zugreifen können.
Spezifizierer Selbe Klasse Abgeleitete Klasse Außerhalb der Klasse
public Ja Ja Ja
private Ja Nein Nein
protected Ja Ja Nein

Hinweis: Standardmäßig sind Klassenmitglieder in C ++ private, sofern nicht anders angegeben.

Interessante Beiträge...