UN classe di amici può accedere ai membri privati ​​e protetti di altre classi in cui è dichiarato amico. A volte è utile consentire a una classe particolare di accedere ai membri privati ​​e protetti di altre classi. Ad esempio, una classe LinkedList può essere autorizzata ad accedere ai membri privati ​​di Node.

Possiamo dichiarare una classe amico in C++ utilizzando il metodo amico parola chiave.

Sintassi:

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

Classe di amici

aprire il menu delle impostazioni

Esempio:

// 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: Possiamo dichiarare la classe o la funzione amico in qualsiasi punto del corpo della classe base, sia che si tratti di un blocco privato, protetto o pubblico. Funziona lo stesso.

Funzione amico

Come una classe amico, a una funzione amico può essere concesso un accesso speciale ai membri privati ​​e protetti di una classe in C++. Non sono le funzioni membro della classe ma possono accedere e manipolare i membri privati ​​e protetti di quella classe poiché vengono dichiarati amici.

anno di invenzione del computer

Una funzione amico può essere:

1. Una funzione globale
2. Una funzione membro di un'altra classe

Funzione amico in C++

Sintassi:

alfabeto in numeri

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>

Sintassi della funzione amico

1. Funzione Globale come Funzione Amica

Possiamo dichiarare qualsiasi funzione globale come funzione amico. L'esempio seguente mostra come dichiarare una funzione globale come funzione friend in C++:

Esempio:

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

Nell'esempio sopra, abbiamo utilizzato una funzione globale come funzione amico. Nel prossimo esempio utilizzeremo una funzione membro di un'altra classe come funzione amico.

2. Funzione membro di un'altra classe come funzione amico

Possiamo anche dichiarare una funzione membro di un'altra classe come funzione amico in C++. L'esempio seguente dimostra come utilizzare una funzione membro di un'altra classe come funzione amico in C++:

math.random java

Esempio:

// 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'ordine in cui definiamo la funzione amico di un'altra classe è importante e dovrebbe essere curato. Dobbiamo sempre definire entrambe le classi prima della definizione della funzione. Ecco perché abbiamo utilizzato la definizione della funzione membro della classe.

Caratteristiche delle funzioni amico

• Una funzione amico è una funzione speciale in C++ che, nonostante non sia una funzione membro di una classe, ha il privilegio di farlo accesso IL dati privati ​​e protetti di una classe.
• Una funzione amico è una funzione non membro o una funzione ordinaria di una classe, che viene dichiarata come amico utilizzando la parola chiave amico all'interno della classe. Dichiarando una funzione come amica, alla funzione vengono concessi tutti i permessi di accesso.
• La parola chiave amico viene inserita solo nella dichiarazione della funzione amico e non nel definizione o chiamata di funzione.
• Una funzione amico è chiamata come una funzione ordinaria. Non può essere chiamato utilizzando il nome dell'oggetto e l'operatore punto. Tuttavia, può accettare l'oggetto come argomento al cui valore desidera accedere.
• Una funzione amico può essere dichiarata in qualsiasi sezione della classe, ad esempio pubblica, privata o protetta.

Di seguito sono riportati alcuni altri esempi di funzioni amico in diversi scenari:

Una funzione adatta a più classi

// 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 funzione amico ci fornisce un modo per accedere ai dati privati ​​ma ha anche i suoi demeriti. Di seguito è riportato l'elenco dei vantaggi e degli svantaggi delle funzioni amico in C++:

Vantaggi delle funzioni amico

• Una funzione amico è in grado di accedere ai membri senza la necessità di ereditare la classe.
• La funzione amico funge da ponte tra due classi accedendo ai loro dati privati.
• Può essere utilizzato per aumentare la versatilità degli operatori sovraccarichi.
• Può essere dichiarato nella parte pubblica, privata o protetta della classe.

Svantaggi delle funzioni amico

• Le funzioni Friend hanno accesso ai membri privati ​​di una classe dall'esterno della classe, il che viola la legge sull'occultamento dei dati.
• Le funzioni Friend non possono eseguire alcun polimorfismo in fase di esecuzione nei propri membri.

Punti importanti sulle funzioni e classi degli amici

1. Gli amici dovrebbero essere utilizzati solo per scopi limitati. Troppe funzioni o classi esterne vengono dichiarate come amiche di una classe con accesso ai dati protetto o privato diminuisce il valore dell'incapsulamento di classi separate nella programmazione orientata agli oggetti.
2. L'amicizia è non reciproco . Se la classe A è amica di B, allora B non diventa automaticamente amico di A.
3. L'amicizia non si eredita. (Vedere Questo per ulteriori dettagli)
4. Il concetto di amici non è in Java.