A Freundesklasse kann auf private und geschützte Mitglieder anderer Klassen zugreifen, in denen es als Freund deklariert ist. Manchmal ist es nützlich, einer bestimmten Klasse den Zugriff auf private und geschützte Mitglieder anderer Klassen zu erlauben. Beispielsweise kann einer LinkedList-Klasse der Zugriff auf private Mitglieder von Node gestattet werden.

Wir können eine Friend-Klasse in C++ deklarieren, indem wir die verwenden Freund Stichwort.

Syntax:

friend class class_name; // declared in the base class>

Freundesklasse

Beispiel:

// C++ Program to demonstrate the // functioning of a friend class #include  using namespace std; class GFG { private:  int private_variable; protected:  int protected_variable; public:  GFG()  {  private_variable = 10;  protected_variable = 99;  }  // friend class declaration  friend class F; }; // Here, class F is declared as a // friend inside class GFG. Therefore, // F is a friend of class GFG. Class F // can access the private members of // class GFG. class F { public:  void display(GFG& t)  {  cout << 'The value of Private Variable = '  << t.private_variable << endl;  cout << 'The value of Protected Variable = '  << t.protected_variable;  } }; // Driver code int main() {  GFG g;  F fri;  fri.display(g);  return 0; }>

The value of Private Variable = 10 The value of Protected Variable = 99>

Notiz: Wir können eine Friend-Klasse oder -Funktion überall im Basisklassenkörper deklarieren, unabhängig davon, ob es sich um einen privaten, geschützten oder öffentlichen Block handelt. Es funktioniert trotzdem.

Freundefunktion

Wie einer Friend-Klasse kann auch einer Friend-Funktion besonderer Zugriff auf private und geschützte Mitglieder einer Klasse in C++ gewährt werden. Sie sind keine Mitgliedsfunktionen der Klasse, können aber auf die privaten und geschützten Mitglieder dieser Klasse zugreifen und diese manipulieren, da sie als Freunde deklariert sind.

Eine Freundesfunktion kann sein:

1. Eine globale Funktion
2. Eine Mitgliedsfunktion einer anderen Klasse

Friend-Funktion in C++

Syntax:

friend return_type function_name (arguments); // for a global function  or friend return_type class_name::function_name (arguments); // for a member function of another class>

Syntax der Friend-Funktion

1. Globale Funktion als Freundfunktion

Wir können jede globale Funktion als Friend-Funktion deklarieren. Das folgende Beispiel zeigt, wie eine globale Funktion in C++ als Friend-Funktion deklariert wird:

Beispiel:

// C++ program to create a global function as a friend // function of some class #include  using namespace std; class base { private:  int private_variable; protected:  int protected_variable; public:  base()  {  private_variable = 10;  protected_variable = 99;  }    // friend function declaration  friend void friendFunction(base& obj); }; // friend function definition void friendFunction(base& obj) {  cout << 'Private Variable: ' << obj.private_variable  << endl;  cout << 'Protected Variable: ' << obj.protected_variable; } // driver code int main() {  base object1;  friendFunction(object1);  return 0; }>

Private Variable: 10 Protected Variable: 99>

Im obigen Beispiel haben wir eine globale Funktion als Friend-Funktion verwendet. Im nächsten Beispiel verwenden wir eine Member-Funktion einer anderen Klasse als Friend-Funktion.

2. Mitgliedsfunktion einer anderen Klasse als Freundfunktion

Wir können in C++ auch eine Mitgliedsfunktion einer anderen Klasse als Friend-Funktion deklarieren. Das folgende Beispiel zeigt, wie man eine Member-Funktion einer anderen Klasse als Friend-Funktion in C++ verwendet:

Beispiel:

// C++ program to create a member function of another class // as a friend function #include  using namespace std; class base; // forward definition needed // another class in which function is declared class anotherClass { public:  void memberFunction(base& obj); }; // base class for which friend is declared class base { private:  int private_variable; protected:  int protected_variable; public:  base()  {  private_variable = 10;  protected_variable = 99;  }  // friend function declaration  friend void anotherClass::memberFunction(base&); }; // friend function definition void anotherClass::memberFunction(base& obj) {  cout << 'Private Variable: ' << obj.private_variable  << endl;  cout << 'Protected Variable: ' << obj.protected_variable; } // driver code int main() {  base object1;  anotherClass object2;  object2.memberFunction(object1);  return 0; }>

Private Variable: 10 Protected Variable: 99>

Notiz : Die Reihenfolge, in der wir die Friend-Funktion einer anderen Klasse definieren, ist wichtig und sollte beachtet werden. Wir müssen immer beide Klassen vor der Funktionsdefinition definieren. Aus diesem Grund haben wir die Funktionsdefinition außerhalb der Klasse verwendet.

Merkmale von Friend-Funktionen

• Eine Friend-Funktion ist eine spezielle Funktion in C++, die, obwohl sie keine Mitgliedsfunktion einer Klasse ist, dazu berechtigt ist Zugang Die private und geschützte Daten einer Klasse.
• Eine Friend-Funktion ist eine Nichtmitgliedsfunktion oder eine gewöhnliche Funktion einer Klasse, die mit dem Schlüsselwort als Friend deklariert wird Freund innerhalb der Klasse. Durch die Deklaration einer Funktion als Freund werden der Funktion alle Zugriffsberechtigungen erteilt.
• Das Schlüsselwort Friend wird nur in der Funktionsdeklaration der Friend-Funktion und platziert nicht im Funktionsdefinition oder -aufruf.
• Eine Friend-Funktion wird wie eine gewöhnliche Funktion aufgerufen. Es kann nicht mit dem Objektnamen und dem Punktoperator aufgerufen werden. Es kann jedoch das Objekt als Argument akzeptieren, auf dessen Wert es zugreifen möchte.
• Eine Friend-Funktion kann in jedem Abschnitt der Klasse deklariert werden, d. h. öffentlich, privat oder geschützt.

Nachfolgend finden Sie einige weitere Beispiele für Friend-Funktionen in verschiedenen Szenarien:

Eine Funktion, die für mehrere Klassen geeignet ist

// C++ Program to demonstrate  // how friend functions work as // a bridge between the classes #include  using namespace std; // Forward declaration class ABC;  class XYZ {  int x; public:  void set_data(int a)   {   x = a;   }  friend void max(XYZ, ABC); }; class ABC {  int y; public:  void set_data(int a)   {   y = a;   }  friend void max(XYZ, ABC); }; void max(XYZ t1, ABC t2) {  if (t1.x>t2.y) cout<< t1.x;  else  cout << t2.y; } // Driver code int main() {  ABC _abc;  XYZ _xyz;  _xyz.set_data(20);  _abc.set_data(35);  // calling friend function  max(_xyz, _abc);   return 0; }>

35>

Die Friend-Funktion bietet uns die Möglichkeit, auf private Daten zuzugreifen, hat aber auch ihre Vorzüge. Im Folgenden finden Sie eine Liste der Vor- und Nachteile von Friend-Funktionen in C++:

Vorteile von Friend-Funktionen

• Eine Friend-Funktion kann auf Mitglieder zugreifen, ohne dass die Klasse geerbt werden muss.
• Die Friend-Funktion fungiert als Brücke zwischen zwei Klassen, indem sie auf deren private Daten zugreift.
• Es kann verwendet werden, um die Vielseitigkeit überlasteter Bediener zu erhöhen.
• Es kann entweder im öffentlichen oder privaten oder geschützten Teil der Klasse deklariert werden.

Nachteile von Friend-Funktionen

• Friend-Funktionen haben Zugriff auf private Mitglieder einer Klasse von außerhalb der Klasse, was gegen das Gesetz des Datenverbergens verstößt.
• Friend-Funktionen können in ihren Mitgliedern keinen Laufzeitpolymorphismus durchführen.

Wichtige Punkte zu Friend-Funktionen und -Klassen

1. Freunde sollten nur für begrenzte Zwecke verwendet werden. Wenn zu viele Funktionen oder externe Klassen als Freunde einer Klasse mit geschütztem oder privatem Datenzugriff deklariert werden, verringert sich der Wert der Kapselung separater Klassen in der objektorientierten Programmierung.
2. Freundschaft ist nicht gegenseitig . Wenn Klasse A ein Freund von B ist, wird B nicht automatisch ein Freund von A.
3. Freundschaft wird nicht vererbt. (Sehen Das für mehr Details)
4. Das Konzept der Freunde gibt es in Java nicht.