Fonction amie C++ et classes amies
Fonction amie C++ et classes amies
Dans ce tutoriel, nous allons apprendre à créer des fonctions amies et des classes amies en C++ à l'aide d'exemples.
Le masquage de 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 les 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 amies qui enfreignent cette règle et nous permettent d'accéder aux fonctions membres depuis l'extérieur de la classe.
De même, il existe une classe d'amis également, ce que nous apprendrons plus tard dans ce didacticiel.
Fonction ami en C++
Une fonction ami peut accéder au domaine privé et protégé données d'une classe. On déclare une fonction ami en utilisant le friend mot-clé dans le corps de la classe.
class className {
... .. ...
friend returnType functionName(arguments);
... .. ...
} Exemple 1 :Fonctionnement de la fonction friend
// C++ program to demonstrate the working of friend function
#include <iostream>
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;
} Sortie
Distance: 5
Ici, addFive() est une fonction d'ami qui peut accéder à la fois privé et public membres de données.
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 <iostream>
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;
} Sortie
Sum: 13
Dans ce programme, ClassA et ClassB ont déclaré add() en tant que fonction d'ami. Ainsi, cette fonction peut accéder à privé données des deux classes.
Une chose à remarquer ici est la fonction ami à l'intérieur de ClassA utilise 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 avancée de ClassB dans notre programme.
// forward declaration
class ClassB; classe ami en C++
Nous pouvons également utiliser une classe amie en C++ en utilisant le friend mot-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 amie deviennent des fonctions amies.
Depuis ClassB est une classe d'amis, nous pouvons accéder à tous les membres de ClassA de l'intérieur ClassB .
Cependant, nous ne pouvons pas accéder aux membres de ClassB de l'intérieur ClassA . C'est parce que la relation d'ami en C++ est seulement accordée, pas prise.
Exemple 3 :Classe ami C++
// C++ program to demonstrate the working of friend class
#include <iostream>
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;
} Sortie
Sum: 13
Ici, ClassB est une classe amie de ClassA . Donc, ClassB a accès aux membres de classA .
En ClassB , nous avons créé une fonction add() qui renvoie la somme de numA et numB .
Depuis ClassB est une classe amie, nous pouvons créer des objets de ClassA à l'intérieur de ClassB .
Langue C