In diesem Tutorial lernen wir anhand von Beispielen, Freundfunktionen und Freundesklassen in C ++ zu erstellen.
Das Verstecken von Daten ist ein grundlegendes Konzept der objektorientierten Programmierung. Es beschränkt den Zugriff privater Mitglieder von außerhalb der Klasse.
Ebenso können geschützte Mitglieder nur von abgeleiteten Klassen aufgerufen werden und sind von außen nicht zugänglich. Beispielsweise,
class MyClass ( private: int member1; ) int main() ( MyClass obj; // Error! Cannot access private members from here. obj.member1 = 5; )
In C ++ gibt es jedoch eine Funktion namens Friend-Funktionen , die gegen diese Regel verstoßen und es uns ermöglichen, von außerhalb der Klasse auf Elementfunktionen zuzugreifen.
Ebenso gibt es auch eine Freundesklasse , die wir später in diesem Tutorial lernen werden.
Freund Funktion in C ++
Eine Friend-Funktion kann auf die privaten und geschützten Daten einer Klasse zugreifen . Wir deklarieren eine Friend-Funktion mit dem friendSchlüsselwort im Hauptteil der Klasse.
class className (… friend returnType functionName(arguments);… )
Beispiel 1: Arbeiten der Freundfunktion
// C++ program to demonstrate the working of friend function #include using namespace std; class Distance ( private: int meter; // friend function friend int addFive(Distance); public: Distance() : meter(0) () ); // friend function definition int addFive(Distance d) ( //accessing private members from the friend function d.meter += 5; return d.meter; ) int main() ( Distance D; cout << "Distance: " << addFive(D); return 0; )
Ausgabe
Entfernung: 5
Hier addFive()ist eine Friend-Funktion, die sowohl auf private als auch auf öffentliche Datenelemente zugreifen kann .
Dieses Beispiel gibt uns zwar eine Vorstellung vom Konzept einer Freundfunktion, zeigt jedoch keine sinnvolle Verwendung.
Eine sinnvollere Verwendung wäre die Bearbeitung von Objekten aus zwei verschiedenen Klassen. Dann kann die Friend-Funktion sehr hilfreich sein.
Beispiel 2: Hinzufügen von Mitgliedern zweier verschiedener Klassen
// Add members of two different classes using friend functions #include using namespace std; // forward declaration class ClassB; class ClassA ( public: // constructor to initialize numA to 12 ClassA() : numA(12) () private: int numA; // friend function declaration friend int add(ClassA, ClassB); ); class ClassB ( public: // constructor to initialize numB to 1 ClassB() : numB(1) () private: int numB; // friend function declaration friend int add(ClassA, ClassB); ); // access members of both classes int add(ClassA objectA, ClassB objectB) ( return (objectA.numA + objectB.numB); ) int main() ( ClassA objectA; ClassB objectB; cout << "Sum: " << add(objectA, objectB); return 0; )
Ausgabe
Summe: 13
In diesem Programm ClassAund ClassBhaben add()als Freund Funktion deklariert . Somit kann diese Funktion auf private Daten beider Klassen zugreifen .
Eine Sache, die hier zu beachten ist, ist, dass die Friend-Funktion im Inneren ClassAdie verwendet ClassB. Wir haben dies jedoch noch nicht definiert ClassB.
// inside classA friend int add(ClassA, ClassB);
Damit dies funktioniert, benötigen wir eine Vorwärtserklärung von ClassBin unserem Programm.
// forward declaration class ClassB;
Freund Klasse in C ++
Wir können auch eine Friend-Klasse in C ++ mit dem friendSchlüsselwort verwenden. Beispielsweise,
class ClassB; class ClassA ( // ClassB is a friend class of ClassA friend class ClassB;… ) class ClassB (… )
Wenn eine Klasse als Freundesklasse deklariert wird, werden alle Mitgliedsfunktionen der Freundesklasse zu Freundfunktionen.
Da classBes sich um eine Freundesklasse handelt, können wir classAvon innen auf alle Mitglieder zugreifen classB.
Wir können jedoch nicht ClassBvon innen auf Mitglieder von zugreifen classA. Dies liegt daran, dass die Freundschaftsbeziehung in C ++ nur gewährt und nicht übernommen wird.
Beispiel 3: C ++ - Freundklasse
// C++ program to demonstrate the working of friend class #include using namespace std; // forward declaration class ClassB; class ClassA ( private: int numA; // friend class declaration friend class ClassB; public: // constructor to initialize numA to 12 ClassA() : numA(12) () ); class ClassB ( private: int numB; public: // constructor to initialize numB to 1 ClassB() : numB(1) () // member function to add numA // from ClassA and numB from ClassB int add() ( ClassA objectA; return objectA.numA + numB; ) ); int main() ( ClassB objectB; cout << "Sum: " << objectB.add(); return 0; )
Ausgabe
Summe: 13
Hier ClassBist eine Freundesklasse von ClassA. Hat ClassBalso Zugriff auf die Mitglieder von classA.
In ClassBhaben wir eine Funktion erstellt add(), die die Summe von numA und numB zurückgibt.
Da ClassBes sich um eine Freundesklasse handelt, können wir Objekte ClassAinnerhalb von erstellen ClassB.
