C++-Programme greifen auf private Mitglieder der Klasse zu

Auf private Mitglieder einer Klasse können nur Mitglieder der Klasse zugreifen. Dies geschieht, um objektorientierte Kapselungsprinzipien beizubehalten und sicherzustellen, dass Daten und die damit verbundenen Funktionen in einer Einheit gespeichert werden und nur von Mitgliedern der Klasse darauf zugegriffen werden kann. C++ verfügt über drei verschiedene Zugriffskontrollen, um die Sichtbarkeit von Mitgliedern einer Klasse festzulegen. Diese drei Zugriffskontrollzeichen sind −

• Öffentlich − Wenn die Mitglieder einer Klasse öffentlich sichtbar sind, kann von jeder anderen Klasse aus auf diese Mitglieder zugegriffen werden.

• Privat − Auf Klassenmitglieder mit privater Sichtbarkeit kann nur innerhalb der Klasse zugegriffen werden.

• Geschützte − geschützte Klassenmitglieder können nur innerhalb der Klasse oder ihrer Unterklassen aufgerufen werden.

In diesem Artikel konzentrieren wir uns nur auf den Zugriff auf private Mitglieder einer Klasse.

Verwenden Sie Getter- und Setter-Methoden, um auf Datenelemente zuzugreifen

Getter- und Setter-Funktionen werden verwendet, um auf private Mitglieder einer Klasse zuzugreifen und diese zu ändern. Wie der Name schon sagt, gibt die Getter-Funktion das Datenelement zurück, während die Setter-Funktion zum „Setzen“ oder Ändern des Datenelements verwendet wird. Wir verwenden zwei Beispiele, um dieses Konzept besser zu verstehen, aber zuvor wird unten die grundlegende Syntax angegeben. Grammatik

Getter-/Accessor-Funktionen −

private:
   <datatype> value;
public:
   <datatype> getterFunction() {
     return <datatype> this->value;
   }

Setter/Mutator-Funktion−

private:
   <datatype> value;
public:
   void setterFunction(<datatype> _value) {
     this->value = _value;
   }

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <iostream>

using namespace std;

class Test{
   private:
      int value;
   public:
      //the getter function
      int getValue() {
         return this->value;
      }
      //the setter function
      void setValue(int _value) {
         this->value = _value;
      }
};

int main(){
   Test test;
   test.setValue(15);
   cout << "The value we set is: " << test.getValue() << endl;
   return 0;
}

Ausgabe

The value we set is: 15

Zugriff auf die Memberfunktion aus einer anderen Funktion heraus

Die gleiche Situation ist, wenn wir auf eine private Mitgliedsfunktion zugreifen. Wir müssen innerhalb der Klassenmember-Methode auf die gleiche Weise darauf zugreifen, wie wir auf die Datenmember zugreifen. Wir können den Zeiger „

this

“ verwenden, um Namenskonflikte zu vermeiden. Grammatik

private:
   <returntype> function_name(params) {};
public:
   <returntype> another_function(params) {
     <datatype> var = this->function_name(arguments);
   }

Funktionen, die private Mitgliedsfunktionen aufrufen, sollten als öffentlich deklariert werden. Die öffentliche Funktion wird nur ausgeführt, wenn sie von einem Objekt dieser Klasse aufgerufen wird.

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <iostream>

using namespace std;

class Test{
   private:
      int value;
      //multiplies the member value by 10
      void multiplyValue() {
         this->value = this->value * 10;
      }
   public:
      //the getvalue function calls the multiply value function
      int multiplyAndGetValue() {
         this->multiplyValue();
         return this->value;
      }
      //the setter function
      void setValue(int _value) {
         this->value = _value;
      }
};

int main(){
   Test test;
   test.setValue(15);
   cout << "The value after setting and multiplying is: " << test.multiplyAndGetValue() << endl;
   return 0;
}

Ausgabe

The value after setting and multiplying is: 150

Verwenden Sie Freundesklassen

In C++ ist eine Freundklasse eine Klasse, die auf private und geschützte Mitglieder anderer Klassen zugreifen kann, die für andere Klassen nicht sichtbar sind. Um eine Klasse als Freund einer anderen Klasse zu deklarieren, verwenden Sie das Schlüsselwort „

friend

“. Mal sehen, wie es funktioniert. Grammatik

class A{
   private:
     .....
   friend class B;
};

class B{
   //class body
};

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <iostream>

using namespace std;

class Test1{
   private:
      int value;
   public:
      Test1(int _value) {
         this->value = _value;
      }
      //we declare another class as a friend
      friend class Test2;
};

class Test2{
  public:
   //displays the value of the other class object
   void display(Test1 &t) {
      cout << "The value of Test1 object is: " << t.value;
   }
};

int main(){
   //creating two class objects of the two classes
   Test1 test1(15);
   Test2 test2;

   //calling the friend class function
   test2.display(test1);
   return 0;
}

Ausgabe

The value of Test1 object is: 15

Freundefunktionen nutzen

In C++ ähneln Friend-Funktionen Friend-Klassen. Hier können wir eine bestimmte Funktion, die kein Mitglied der Klasse ist, als „Freund“ deklarieren und sie erhält Zugriff auf die privaten Mitglieder der Klasse. Schauen wir uns die Syntax an, wie man eine Funktion als „

Freund

“ definiert. Grammatik

class A{
   private:
     .....
   friend <return_type> function_name(params);
};

<return_type> function_name(params) {
   //function body
}

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <iostream>

using namespace std;

class Test1{
   private:
      int value;
   public:
      Test1(int _value) {
         this->value = _value;
      }
      //we declare a friend function
      friend void display(Test1);
};

void display(Test1 t) {
   cout << "The value of Test1 object is: " << t.value;
}

int main(){
   //creating two class objects of the two classes
   Test1 test1(55);
   //calling the friend class function
   display(test1);
   return 0;
}

Ausgabe

The value of Test1 object is: 55

Fazit

Wenn wir auf private Datenmitglieder einer Klasse zugreifen, ist es besser, Zugriffs-/Getter- und Modifikator-/Setter-Funktionen zu verwenden. Dies ist die sicherste Möglichkeit, auf Datenelemente einer Klasse zuzugreifen. Denken Sie immer daran, dass Funktionen, die auf private Mitglieder zugreifen, als öffentlich deklariert werden sollten. Friend-Funktionen sind in anderen objektorientierten Sprachen nicht verfügbar, da dadurch die Eigenschaften der objektorientierten Kapselung nicht immer erhalten bleiben. Die Freundschaftsbeziehung ist asymmetrisch. Wenn Klasse A Klasse B als Freund deklariert, hat Klasse B Zugriff auf alle Mitglieder von A, A kann jedoch nicht auf alle privaten Mitglieder von B zugreifen.

Das obige ist der detaillierte Inhalt vonC++-Programme greifen auf private Mitglieder der Klasse zu. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!