Zugriff auf private Variablen in C++

1. Zugriff auf private Variablen in C++
2. Greifen Sie in C++ mithilfe von Elementfunktionen auf private Variablen zu
3. Greifen Sie in C++ mit friend-Funktionen auf private Variablen zu
4. Greifen Sie in C++ mithilfe von Zeigern auf private Variablen zu
5. Fazit

Dieser Artikel behandelt private C++-Variablen und den Zugriff auf sie in C++.

Zugriff auf private Variablen in C++

Die Kapselung schützt sensible und wichtige Daten vor unbefugten Benutzern. Um dieses Phänomen zu erreichen, wird das Schlüsselwort private verwendet.

Neben der Kapselung ist auch das Data Hiding-Konzept in C++ implementiert. Die mit dem Schlüsselwort private deklarierte Variable signalisiert in C++, dass nur die Member-Funktionen ihrer Klasse auf sie zugreifen können.

Kein Objekt oder keine Funktion kann direkt darauf zugreifen.

#include <iostream>
using namespace std;

class shape {
 private:
  double r;

 public:
  void area(double rr) {
    r = rr;

    double ar = 3.14 * r * r;

    cout << "Radius is: " << r << endl;
    cout << "Area is: " << ar;
  }
};

int main() {
  shape obj;
  obj.area(1.5);

  return 0;
}

Ausgabe:

Radius is: 1.5
Area is: 7.065

Abgesehen von einer friend-Funktion oder einer Member-Funktion der Klasse kann keine Entität auf die privaten Daten-Member der Klasse zugreifen. Hier wird auf die Variable r von der Member-Funktion der Klasse area() zugegriffen.

Die Funktion area() berechnet die Fläche des Kreises, indem sie auf das private Datenelement der Klasse zugreift. Und das Objekt der Klasse wird in der Hauptfunktion der Klasse erstellt.

Über dieses Objekt wird auf die Klassenmitgliedsfunktion zugegriffen und die Fläche des Kreises berechnet.

Die friend-Funktion allein ist nicht der Weg, um auf die privaten Daten der Mitglieder zuzugreifen. Außerdem wird auf private Variablen auch außerhalb einer Klasse mit Zeigern zugegriffen.

Diese Methode, Zeiger für den Zugriff auf private Datenmember zu verwenden, ist eine Lücke in C++. Lesen Sie mit, um mehr darüber zu erfahren.

Greifen Sie in C++ mithilfe von Elementfunktionen auf private Variablen zu

Auf eine private Elementvariable oder -funktion in C++ kann außerhalb der Klasse nicht zugegriffen oder diese angezeigt werden. Das Hauptkonzept von C++ ist sein einzigartiges Merkmal der Datensicherheit.

Auf ein privates Datenelement kann nur durch die Klasse zugegriffen werden, in der es erstellt wurde, und die friend-Funktion seiner Klasse.

Konzentrieren Sie sich auf das folgende Beispiel, um zu erfahren, wie Memberfunktionen der Klasse auf die Datenmember zugreifen.

#include <iostream>
using namespace std;

class Emp {
 private:
  int sal;

 public:
  void setSal(int s) { sal = s; }

  int getSal() { return sal; }
};

int main() {
  Emp myObj;
  myObj.setSal(50000);
  cout << myObj.getSal();
  return 0;
}

Ausgabe:

50000

Im obigen Programm hat die Klasse emp sowohl private als auch öffentliche Mitglieder. sal ist eine private Variable, auf die zwei Klassenmitgliederfunktionen zugreifen können: setSal() und getSal().

setSal() initialisiert den Wert des privaten Datenelements sal, und getSal() gibt den Wert des privaten Datenelements sal zurück. Schließlich wird in der Hauptmethode das Objekt der Klasse erstellt.

Das Objekt myObj greift auf die Memberfunktion der Klasse setSal() zu, um den Wert an das private Datenmember sal zu übergeben. Zuletzt greift das Klassenobjekt auf getSal() zu, um das Datenelement sal zurückzugeben.

Standardmäßig sind alle Mitglieder einer Klasse privat; In der folgenden Klasse ist w beispielsweise ein privates Element. Daher wird es als privates Datenelement betrachtet, bis Sie ein Element als öffentlich oder geschützt kennzeichnen.

class B {
  double w;

 public:
  double len;
  void setW(double wid);
  double get(void);
};

In Echtzeit werden Daten im privaten Bereich definiert und Member-Funktionen im öffentlichen Bereich, um sie von außerhalb der Klasse abzurufen, wie im folgenden Programm gezeigt.

#include <iostream>

using namespace std;

class B {
 public:
  double len;
  void setW(double wid);
  double getW(void);

 private:
  double w;
};

double B::getW(void) { return w; }

void B::setW(double wid) { w = wid; }

int main() {
  B box;

  box.len = 10.0;
  cout << "Length: " << box.len << endl;

  box.setW(10.0);
  cout << "Width: " << box.getW() << endl;

  return 0;
}

Im obigen Programm hat die Klasse B sowohl private als auch öffentliche Mitglieder. Hier ist w eine private Variable, auf die die zweiklassige Elementfunktion zugreifen kann: setW() und getW().

setW() initialisiert den Wert des privaten Datenelements w, und getW() gibt den Wert des privaten Datenelements w zurück. Die Objektbox greift auf die Member-Funktion der Klasse zu.

Die öffentliche Variable len ist über die Objektbox zugänglich und wird mit einem Wert initialisiert. setW() weist dem privaten Datenelement w den angegebenen Wert zu.

Schließlich greift die Klassenobjektbox auf getW() zu, um das Datenelement w zurückzugeben.

Ausgabe:

Length: 10
Width: 10

Greifen Sie in C++ mit friend-Funktionen auf private Variablen zu

Eine friend-Funktion befindet sich im privaten oder öffentlichen Teil der Klasse. Sie kann als normale Elementfunktion aufgerufen werden, ohne das Objekt zu verwenden.

Das Klassenobjekt ruft es nicht auf, da es nicht innerhalb des Gültigkeitsbereichs der Klasse liegt. Außerdem kann es nicht direkt auf die privaten und geschützten Datenelemente der Klasse zugreifen.

Die Funktion friend verwendet das Objekt der Klasse und greift mit dem Punktoperator auf die Mitglieder zu. Es kann eine globale Funktion oder ein Mitglied einer anderen Klasse sein.

#include <iostream>
using namespace std;

class Dist {
 private:
  int m;

  friend int add(Dist);

 public:
  Dist() : m(0) {}
};

int add(Dist d) {
  d.m += 5;
  return d.m;
}

int main() {
  Dist D;
  cout << "Distance: " << add(D);
  return 0;
}

Ausgabe:

Distance = 5

Im obigen Programm sehen wir eine Klasse Dist mit privaten Mitgliedern m. Wir haben einen öffentlichen Konstruktor, der die Werte von m initialisiert.

Dann gibt es noch eine friend-Funktion add(), die mit m die Distanz berechnet. Das add() ist eine friend-Funktion, die nicht im Geltungsbereich der Klasse liegt.

In der Hauptmethode wird ein Objekt der Klasse erstellt und die Funktion add() übergeben. Die Funktion add() berechnet die Distanz und zeigt das Ergebnis an.

friend-Klasse in C++

Eine friend-Klasse ist wie friend-Funktionen, die erstellt werden können. Die Klasse friend kann auf die geheimen und geschützten Mitglieder der Klasse zugreifen, mit der sie befreundet ist.

Ähnlich wie bei friend-Funktionen gibt es eine friend-Klasse. Es kann auf private und geschützte Klassenmitglieder zugreifen, für die es ein friend ist.

Syntax:

class X {
  Data members;
  Member Functions;

  friend class Y;
};

class B {
  ……..
};

Wie in der Syntax gezeigt, ist die Klasse X ein friend der Klasse Y. Das bedeutet, dass die Klasse Y auf die privaten und geschützten Mitglieder der Klasse X zugreifen kann.

Aber diese Freundschaft beruht nicht auf Gegenseitigkeit, und Klasse X kann nicht auf private und geschützte Mitglieder der Klasse Y zugreifen. Wir müssen die Klasse X als friend der Klasse Y bezeichnen.

Außerdem wird die Freundschaft nicht vererbt, sodass die Klasse Y kein friend der untergeordneten Klassen der Klasse X sein wird.

Beispiel für die Klasse friend in C++

#include <iostream>
#include <string>
using namespace std;
class Ar {
  int len, br, arr;

 public:
  Ar(int l, int b) {
    len = l;
    br = b;
  };

  void computeArea() { arr = len * br; }

  friend class prClass;
};
class prClass {
 public:
  void prAr(Ar &a) { cout << "Area = " << a.arr; }
};
int main() {
  Ar a(20, 10);
  a.computeArea();
  prClass p;
  p.prAr(a);

  return 0;
}

Ausgabe:

Area = 200

Im obigen Programm gibt es zwei Klassen. Die Klasse Ar berechnet die Fläche mit den Variablen len und br.

Diese Klasse hat drei private Datenmitglieder: arr, len und br. Die andere erstellte Klasse ist prClass, die die endgültige Fläche ausgibt, die von der Member-Funktion computeArea der Klasse Ar berechnet wurde.

Da alle Datenelemente privat sind, müssen wir die Klasse prClass zu einem friend der Klasse Ar machen, um das Ergebnis zu drucken. Das Objekt der Klasse Ar wird innerhalb der Hauptfunktion erstellt.

Die Flächenberechnung wird durchgeführt und das Objekt der Klasse Ar an die Funktion prClass übergeben. Diese Funktion heisst prAr und zeigt die Fläche an.

Nachteile der Verwendung einer friend-Funktion für den Zugriff auf private Variablen in C++

Das wichtigste Merkmal von C++ ist die Kapselung, also eine Gruppierung von Daten und Funktionen. Datenmember und Memberfunktionen bearbeiten die Daten gemeinsam, sodass keine externe Funktion oder Klasse auf die Daten zugreifen kann.

Die Kapselungsfunktion ist beeinträchtigt, da friend-Funktionen oder -Klassen auf die privaten Mitglieder einer anderen Klasse zugreifen dürfen. Die Datensicherheit gerät in Gefahr.

Greifen Sie in C++ mithilfe von Zeigern auf private Variablen zu

Pointer greifen ohne friend- oder Class-Member-Funktion auf die Daten zu.

#include <bits/stdc++.h>
using namespace std;

class Hello {
 private:
  int c;
  int d;
};

int main() {
  Hello a;
  int* q = (int*)&a;
  *q = 4;
  q++;
  *q = 5;
  q--;
  cout << endl << "c = " << *q;
  q++;
  cout << endl << "d = " << *q;
  return 0;
}

Ausgabe:

c = 4
d = 5

Im obigen Programm ist a ein Objekt der Klasse Hello. Die Adresse des Klassenobjekts a wird dem Integer-Zeiger q durch Typumwandlung zugewiesen.

Der Zeiger q zeigt dann auf das private Element c. Der ganzzahlige Wert wird *q zugewiesen, was c ist.

Dann wird die Adresse des Objekts a erhöht und durch Zugriff auf den Speicherplatz d der Wert 5 zugewiesen. Die Anweisung q-- setzt den Speicherplatz von c.

Mit der Anweisung cout wird c angezeigt.

Fazit

In diesem Artikel haben wir den Zugriff auf eine private Variable in C++ besprochen. Wir haben die verschiedenen Methoden für den Zugriff auf private Member in C++ kennengelernt.

Außerdem haben wir mit vielen Beispielen das Konzept der friend-Funktionen und -Zeiger in C++ besprochen. Eine wichtige Sache, die Sie mitnehmen sollten, ist, dass Objekte nicht in einer Klasse erstellt werden können, deren Elementfunktionen ebenfalls privat sind.

Vor diesem Hintergrund hoffen wir, dass Ihnen das Lesen dieses Artikels Spaß gemacht hat. Bleiben Sie dran für weitere informative Artikel.