L'un des concepts importants de la POO est la dissimulation de données : une fonction non membre ne peut pas accéder aux données privées ou protégées d'un objet. Mais parfois, cette restriction force le programmeur à écrire des codes longs et complexes.
En C++, le mécanisme friend permet d'accorder un accès privilégié à des fonctions ou classes extérieures, sans rompre l'encapsulation globale.
Fonction amie
Une fonction amie est définie en dehors de la portée d'une classe, mais elle a le droit d'accéder à tous ses membres privés et protégés. Elle est déclarée dans la classe avec le mot-clé friend.
class nomClasse {
...
friend type_retour nomFonction(liste des paramètres);
...
};
type_retour nomFonction(liste des paramètres) {
// Accès aux membres privés/protégés de nomClasse autorisé ici
}Exemple n°1 — Fonction amie simple
#include <iostream>
using namespace std;
class Voiture {
private:
int Id;
double Vitesse;
public:
Voiture();
friend void rouler(Voiture, double);
};
Voiture::Voiture() {
Id = 1;
Vitesse = 240;
}
void rouler(Voiture v, double vitesse) {
v.Vitesse += vitesse;
cout << "la vitesse de v est " << v.Vitesse << endl;
}
int main() {
Voiture v1;
rouler(v1, 24);
return 0;
}la vitesse de v est 264
Exemple n°2 — Fonction amie partagée entre deux classes
Une utilisation plus significative consiste à opérer sur des objets de deux classes différentes. Ici, la fonction addition est amie des deux classes A et B.
Lorsque la classe A référence la classe B dans une déclaration friend, la classe B doit avoir été déclarée à l'avance (forward declaration) avant la définition de A.
#include <iostream>
using namespace std;
class B; // déclaration anticipée de B
class A {
private:
int nombre;
public:
A(int n) : nombre(n) {}
friend void addition(A, B);
};
class B {
private:
int val;
public:
B(int n) : val(n) {}
friend void addition(A, B);
};
void addition(A a, B b) {
int res = a.nombre + b.val;
cout << "le résultat est " << res << endl;
}
int main() {
A a(24);
B b(10);
addition(a, b);
return 0;
}le résultat est 34
Classe amie
Une classe amie est une classe dont toutes les fonctions membres ont accès aux membres privés et protégés de la classe qui la déclare amie. On utilise le mot-clé friend class.
class B;
class A {
...
friend class B;
};
class B {
// toutes les méthodes de B peuvent accéder aux membres privés de A
};Points importants à retenir
| Propriété | Comportement |
|---|---|
| Réciprocité | L'amitié n'est pas réciproque : si A est amie de B, B n'est pas automatiquement amie de A |
| Héritage | L'amitié n'est pas héritée : une sous-classe ne reçoit pas les droits d'amitié de sa classe parent |
| Usage | À utiliser avec parcimonie : trop de fonctions amies affaiblit l'encapsulation |
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.