A vrienden klasse heeft toegang tot privé- en beschermde leden van andere klassen waarin hij als vriend is verklaard. Soms is het handig om een ​​bepaalde klasse toegang te geven tot privé- en beschermde leden van andere klassen. Een LinkedList-klasse kan bijvoorbeeld toegang krijgen tot privéleden van Node.

We kunnen een vriendenklasse in C++ declareren met behulp van de vriend trefwoord.

Syntaxis:

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

Vrienden klasse

Voorbeeld:

// 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>

Opmerking: We kunnen overal in de basisklasse een vriendenklasse declareren of functioneren, of het nu een privé-, beschermd of openbaar blok is. Het werkt allemaal hetzelfde.

Vriend Functie

Net als bij een vriendenklasse kan aan een vriendenfunctie speciale toegang worden verleend aan privé- en beschermde leden van een klasse in C++. Ze zijn niet de ledenfuncties van de klasse, maar kunnen toegang krijgen tot de privé- en beschermde leden van die klasse en deze manipuleren, omdat ze als vrienden worden verklaard.

Een vriendenfunctie kan zijn:

1. Een mondiale functie
2. Een lidfunctie van een andere klasse

Vriendfunctie in C++

Syntaxis:

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>

Vriendfunctiesyntaxis

1. Mondiale functie als vriendfunctie

We kunnen elke globale functie als vriendfunctie declareren. Het volgende voorbeeld laat zien hoe u een globale functie declareert als een vriendfunctie in C++:

Voorbeeld:

// 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>

In het bovenstaande voorbeeld hebben we een globale functie als vriendfunctie gebruikt. In het volgende voorbeeld gebruiken we een lidfunctie van een andere klasse als vriendfunctie.

2. Lidfunctie van een andere klas als vriendfunctie

We kunnen een lidfunctie van een andere klasse ook declareren als een vriendfunctie in C++. Het volgende voorbeeld laat zien hoe u een lidfunctie van een andere klasse als vriendfunctie in C++ kunt gebruiken:

Voorbeeld:

ingesteld in Java

// 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>

Opmerking : De volgorde waarin we de vriendenfunctie van een andere klasse definiëren is belangrijk en er moet rekening mee worden gehouden. We moeten altijd beide klassen definiëren vóór de functiedefinitie. Daarom hebben we de functiedefinitie van leden buiten de klasse gebruikt.

Kenmerken van vriendfuncties

• Een vriendfunctie is een speciale functie in C++ waartoe de functie, ondanks dat hij geen lid is van een klasse, het voorrecht heeft toegang de privé en beschermde gegevens van een klas.
• Een vriendfunctie is een niet-lidfunctie of gewone functie van een klasse, die als vriend wordt gedeclareerd met behulp van het trefwoord vriend binnen de klas. Door een functie als vriend te declareren, worden alle toegangsrechten aan de functie gegeven.
• Het trefwoord vriend wordt alleen in de functiedeclaratie van de vriendfunctie en geplaatst niet in de functiedefinitie of oproep.
• Een vriendfunctie wordt aangeroepen als een gewone functie. Het kan niet worden aangeroepen met behulp van de objectnaam en de puntoperator. Het kan het object echter wel accepteren als een argument waarvan het de waarde wil benaderen.
• Een vriendfunctie kan in elke sectie van de klasse worden gedeclareerd, d.w.z. openbaar, privé of beschermd.

Hieronder staan ​​nog enkele voorbeelden van vriendenfuncties in verschillende scenario's:

Een functie die geschikt is voor meerdere klassen

// 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) uit<< 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>

De vriendenfunctie biedt ons een manier om toegang te krijgen tot privégegevens, maar heeft ook zijn nadelen. Hieronder volgt de lijst met voor- en nadelen van vriendfuncties in C++:

Voordelen van vriendfuncties

• Een vriendenfunctie geeft toegang tot leden zonder dat u de klasse hoeft te erven.
• De vriendenfunctie fungeert als brug tussen twee klassen door toegang te krijgen tot hun privégegevens.
• Het kan worden gebruikt om de veelzijdigheid van overbelaste machinisten te vergroten.
• Het kan worden gedeclareerd in het publieke, private of beschermde deel van de klasse.

Nadelen van vriendfuncties

• Vriendfuncties hebben toegang tot privéleden van een klas van buiten de klas, wat in strijd is met de wet van het verbergen van gegevens.
• Vriendfuncties kunnen geen runtime-polymorfisme in hun leden uitvoeren.

Belangrijke punten over vriendfuncties en klassen

1. Vrienden mogen alleen voor beperkte doeleinden worden gebruikt. Te veel functies of externe klassen worden aangemerkt als vrienden van een klasse met beschermde of privégegevenstoegang, waardoor de waarde van het inkapselen van afzonderlijke klassen bij objectgeoriënteerd programmeren afneemt.
2. Vriendschap is niet wederzijds . Als klasse A een vriend van B is, wordt B niet automatisch een vriend van A.
3. Vriendschap is niet erfelijk. (Zien dit voor meer details)
4. Het concept van vrienden bestaat niet op Java.