A classe d'amics pot accedir a membres privats i protegits d'altres classes en què es declari com a amic. De vegades és útil permetre que una classe en particular accedeixi a membres privats i protegits d'altres classes. Per exemple, una classe LinkedList pot tenir accés a membres privats de Node.

Podem declarar una classe amiga en C++ utilitzant el amic paraula clau.

Sintaxi:

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

Classe d'amics

Exemple:

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

Nota: Podem declarar una classe o funció amiga en qualsevol lloc del cos de la classe base, ja sigui el seu bloc privat, protegit o públic. Funciona igual.

estampat d'estrelles

Funció d'amic

Igual que una classe amiga, es pot concedir a una funció amiga un accés especial als membres privats i protegits d'una classe en C++. No són les funcions membres de la classe, però poden accedir i manipular els membres privats i protegits d'aquesta classe perquè es declaren amics.

Una funció d'amic pot ser:

1. Una funció global
2. Una funció membre d'una altra classe

Funció d'amic en C++

Sintaxi:

linux $home

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>

Sintaxi de la funció d'amic

1. Funció global com a funció d'amic

Podem declarar qualsevol funció global com a funció amiga. L'exemple següent mostra com declarar una funció global com a funció amiga en C++:

Exemple:

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

A l'exemple anterior, hem utilitzat una funció global com a funció amiga. En el següent exemple, utilitzarem una funció membre d'una altra classe com a funció amiga.

2. Funció de membre d'una altra classe com a funció d'amic

També podem declarar una funció membre d'una altra classe com a funció amiga en C++. L'exemple següent mostra com utilitzar una funció membre d'una altra classe com a funció amiga en C++:

Exemple:

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

Nota : L'ordre en què definim la funció d'amic d'una altra classe és important i s'ha de tenir en compte. Sempre hem de definir les dues classes abans de la definició de la funció. Per això hem utilitzat una definició de funció membre fora de classe.

Característiques de les funcions d'amic

• Una funció amiga és una funció especial en C++ que, malgrat no ser una funció membre d'una classe, té el privilegi de accés el dades privades i protegides d'una classe.
• Una funció amiga és una funció no membre o funció ordinària d'una classe, que es declara com a amiga mitjançant la paraula clau amic dins de la classe. En declarar una funció com a amiga, es donen tots els permisos d'accés a la funció.
• La paraula clau amic només es col·loca a la declaració de funció de la funció amic i no en el definició de funció o trucada.
• Una funció amiga s'anomena com una funció ordinària. No es pot cridar amb el nom de l'objecte i l'operador de punt. Tanmateix, pot acceptar l'objecte com un argument al valor del qual vol accedir.
• Una funció amiga es pot declarar en qualsevol secció de la classe, és a dir, pública o privada o protegida.

A continuació es mostren alguns exemples més de funcions d'amic en diferents escenaris:

Una funció amigable per a diverses classes

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

La funció d'amic ens proporciona una manera d'accedir a dades privades però també té els seus demèrits. A continuació es mostra la llista d'avantatges i desavantatges de les funcions amiga en C++:

Avantatges de les funcions d'amic

• Una funció d'amic pot accedir als membres sense necessitat d'heretar la classe.
• La funció d'amic actua com a pont entre dues classes accedint a les seves dades privades.
• Es pot utilitzar per augmentar la versatilitat dels operadors sobrecarregats.
• Es pot declarar en la part pública o privada o protegida de la classe.

Desavantatges de les funcions d'amic

• Les funcions d'amic tenen accés als membres privats d'una classe des de fora de la classe, cosa que infringeix la llei d'amagat de dades.
• Les funcions amigues no poden fer cap polimorfisme en temps d'execució en els seus membres.

Punts importants sobre les funcions i les classes d'amics

1. Els amics només s'han d'utilitzar amb finalitats limitades. Es declaren massa funcions o classes externes com a amigues d'una classe amb accés a dades protegides o privades redueixen el valor de l'encapsulació de classes separades en la programació orientada a objectes.
2. L'amistat és no mutu . Si la classe A és amiga de B, llavors B no esdevé amiga de A automàticament.
3. L'amistat no s'hereta. (Veure això per a més detalls)
4. El concepte d'amics no està a Java.