Zugriff auf private Variablen in C++
- Zugriff auf private Variablen in C++
- Greifen Sie in C++ mithilfe von Elementfunktionen auf private Variablen zu
-
Greifen Sie in C++ mit
friend
-Funktionen auf private Variablen zu - Greifen Sie in C++ mithilfe von Zeigern auf private Variablen zu
- Fazit
![Zugriff auf private Variablen in C++](/img/Cpp/feature-image---access-private-variable-cpp.webp)
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.