Dans ce tutoriel, nous allons apprendre à créer des fonctions et des classes d'amis en C ++ à l'aide d'exemples.
Le masquage des données est un concept fondamental de la programmation orientée objet. Il restreint l'accès des membres privés de l'extérieur de la classe.
De même, les membres protégés ne sont accessibles que par des classes dérivées et sont inaccessibles de l'extérieur. Par exemple,
class MyClass ( private: int member1; ) int main() ( MyClass obj; // Error! Cannot access private members from here. obj.member1 = 5; )
Cependant, il existe une fonctionnalité en C ++ appelée fonctions friend qui enfreignent cette règle et nous permettent d'accéder aux fonctions membres de l'extérieur de la classe.
De même, il existe également une classe d'amis , que nous apprendrons plus tard dans ce tutoriel.
Fonction friend en C ++
Une fonction ami peut accéder aux données privées et protégées d'une classe. Nous déclarons une fonction friend en utilisant le friendmot - clé à l'intérieur du corps de la classe.
class className (… friend returnType functionName(arguments);… )
Exemple 1: Fonctionnement de la fonction ami
// C++ program to demonstrate the working of friend function #include using namespace std; class Distance ( private: int meter; // friend function friend int addFive(Distance); public: Distance() : meter(0) () ); // friend function definition int addFive(Distance d) ( //accessing private members from the friend function d.meter += 5; return d.meter; ) int main() ( Distance D; cout << "Distance: " << addFive(D); return 0; )
Production
Distance: 5
Voici addFive()une fonction d'ami qui peut accéder aux données membres privées et publiques .
Bien que cet exemple nous donne une idée du concept de fonction d'ami, il ne montre aucune utilisation significative.
Une utilisation plus significative serait d'opérer sur des objets de deux classes différentes. C'est alors que la fonction ami peut être très utile.
Exemple 2: ajouter des membres de deux classes différentes
// Add members of two different classes using friend functions #include using namespace std; // forward declaration class ClassB; class ClassA ( public: // constructor to initialize numA to 12 ClassA() : numA(12) () private: int numA; // friend function declaration friend int add(ClassA, ClassB); ); class ClassB ( public: // constructor to initialize numB to 1 ClassB() : numB(1) () private: int numB; // friend function declaration friend int add(ClassA, ClassB); ); // access members of both classes int add(ClassA objectA, ClassB objectB) ( return (objectA.numA + objectB.numB); ) int main() ( ClassA objectA; ClassB objectB; cout << "Sum: " << add(objectA, objectB); return 0; )
Production
Somme: 13
Dans ce programme, ClassAet ClassBont déclaré add()une fonction d'ami. Ainsi, cette fonction peut accéder aux données privées des deux classes.
Une chose à noter ici est que la fonction ami à l'intérieur ClassAutilise le ClassB. Cependant, nous n'avons pas défini ClassBà ce stade.
// inside classA friend int add(ClassA, ClassB);
Pour que cela fonctionne, nous avons besoin d'une déclaration préalable ClassBdans notre programme.
// forward declaration class ClassB;
Classe ami en C ++
Nous pouvons également utiliser une classe friend en C ++ en utilisant le friendmot - clé. Par exemple,
class ClassB; class ClassA ( // ClassB is a friend class of ClassA friend class ClassB;… ) class ClassB (… )
Lorsqu'une classe est déclarée classe amie, toutes les fonctions membres de la classe friend deviennent des fonctions friend.
Puisqu'il classBs'agit d'une classe d'amis, nous pouvons accéder à tous les membres de classAde l'intérieur classB.
Cependant, nous ne pouvons pas accéder aux membres de ClassBde l'intérieur classA. C'est parce que la relation d'ami en C ++ est seulement accordée, pas prise.
Exemple 3: Classe amie C ++
// C++ program to demonstrate the working of friend class #include using namespace std; // forward declaration class ClassB; class ClassA ( private: int numA; // friend class declaration friend class ClassB; public: // constructor to initialize numA to 12 ClassA() : numA(12) () ); class ClassB ( private: int numB; public: // constructor to initialize numB to 1 ClassB() : numB(1) () // member function to add numA // from ClassA and numB from ClassB int add() ( ClassA objectA; return objectA.numA + numB; ) ); int main() ( ClassB objectB; cout << "Sum: " << objectB.add(); return 0; )
Production
Somme: 13
Ici, ClassBest une classe d'amis de ClassA. Donc, ClassBa accès aux membres de classA.
Dans ClassB, nous avons créé une fonction add()qui renvoie la somme de numA et numB.
Puisqu'il ClassBs'agit d'une classe amie, nous pouvons créer des objets de l' ClassAintérieur de ClassB.
