UN classe d'amis peut accéder aux membres privés et protégés des autres classes dans lesquelles il est déclaré ami. Il est parfois utile d'autoriser une classe particulière à accéder aux membres privés et protégés d'autres classes. Par exemple, une classe LinkedList peut être autorisée à accéder aux membres privés de Node.

Nous pouvons déclarer une classe amie en C++ en utilisant le ami mot-clé.

méthodes de chaîne en Java

Syntaxe:

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

Classe d'ami

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>

Note: Nous pouvons déclarer une classe amie ou fonctionner n'importe où dans le corps de la classe de base, qu'il s'agisse d'un bloc privé, protégé ou public. Cela fonctionne tout de même.

Fonction ami

Comme une classe amie, une fonction amie peut bénéficier d’un accès spécial aux membres privés et protégés d’une classe en C++. Ce ne sont pas des fonctions membres de la classe mais peuvent accéder et manipuler les membres privés et protégés de cette classe car ils sont déclarés amis.

Une fonction ami peut être :

1. Une fonction globale
2. Une fonction membre d'une autre classe

Fonction ami en C++

langage informatique génial

Syntaxe:

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>

Syntaxe de la fonction ami

1. Fonction globale en tant que fonction ami

Nous pouvons déclarer n’importe quelle fonction globale comme fonction amie. L'exemple suivant montre comment déclarer une fonction globale en tant que fonction amie 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>

Dans l'exemple ci-dessus, nous avons utilisé une fonction globale comme fonction amie. Dans l’exemple suivant, nous utiliserons une fonction membre d’une autre classe comme fonction amie.

2. Fonction membre d'une autre classe en tant que fonction ami

Nous pouvons également déclarer une fonction membre d’une autre classe comme fonction amie en C++. L'exemple suivant montre comment utiliser une fonction membre d'une autre classe comme fonction amie en C++ :

Exemple:

java util date

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

Note : L'ordre dans lequel nous définissons la fonction ami d'une autre classe est important et doit être pris en compte. Nous devons toujours définir les deux classes avant la définition de la fonction. C'est pourquoi nous avons utilisé une définition de fonction membre hors classe.

Caractéristiques des fonctions d'ami

• Une fonction ami est une fonction spéciale en C++ qui, bien qu'elle ne soit pas une fonction membre d'une classe, a le privilège de accéder le données privées et protégées d'une classe.
• Une fonction ami est une fonction non membre ou une fonction ordinaire d'une classe, qui est déclarée comme ami à l'aide du mot-clé ami à l'intérieur de la classe. En déclarant une fonction comme amie, toutes les autorisations d'accès sont données à la fonction.
• Le mot-clé ami est placé uniquement dans la déclaration de fonction de la fonction ami et pas dans le définition ou appel de fonction.
• Une fonction ami est appelée comme une fonction ordinaire. Il ne peut pas être appelé à l'aide du nom de l'objet et de l'opérateur point. Cependant, il peut accepter l'objet comme argument dont il souhaite accéder à la valeur.
• Une fonction ami peut être déclarée dans n'importe quelle section de la classe, c'est-à-dire publique, privée ou protégée.

Vous trouverez ci-dessous quelques exemples supplémentaires de fonctions d'amis dans différents scénarios :

Une fonction conviviale pour plusieurs 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 fonction ami nous offre un moyen d'accéder à des données privées mais elle a aussi ses inconvénients. Voici la liste des avantages et des inconvénients des fonctions amies en C++ :

Avantages des fonctions amis

• Une fonction ami est capable d'accéder aux membres sans avoir besoin d'hériter de la classe.
• La fonction ami fait office de pont entre deux classes en accédant à leurs données privées.
• Il peut être utilisé pour augmenter la polyvalence des opérateurs surchargés.
• Elle peut être déclarée soit dans la partie publique, soit dans la partie privée ou protégée de la classe.

Inconvénients des fonctions d'ami

• Les fonctions amies ont accès aux membres privés d'une classe extérieurs à la classe, ce qui viole la loi de la dissimulation des données.
• Les fonctions amies ne peuvent effectuer aucun polymorphisme d'exécution dans leurs membres.

Points importants sur les fonctions et les classes d'amis

1. Les amis ne doivent être utilisés qu’à des fins limitées. Trop de fonctions ou de classes externes sont déclarées comme amies d'une classe avec un accès aux données protégé ou privé, ce qui diminue la valeur de l'encapsulation de classes distinctes dans la programmation orientée objet.
2. L'amitie c'est pas réciproque . Si la classe A est amie de B, alors B ne devient pas automatiquement amie de A.
3. L'amitié ne s'hérite pas. (Voir ce pour plus de détails)
4. Le concept d'amis n'est pas en Java.