Fonctions amies et classes amies en C++ : Maîtriser le contrôle d'accès

Fonctions amies et classes amies en C++ : Maîtriser le contrôle d'accès

Ce tutoriel démontre comment déclarer et utiliser les fonctions amies et classes amies en C++, avec des exemples clairs.

Le masquage de données est une pierre angulaire de la programmation orientée objet, empêchant le code externe d'accéder directement aux membres privés d'une classe. Les membres protégés ne sont visibles que pour les classes dérivées et restent inaccessibles depuis le monde extérieur.

Considérez l'exemple suivant :

class MyClass {
private:
    int member1;
};
int main() {
    MyClass obj;
    // Erreur ! Ne peut pas accéder aux membres privés depuis ici.
    obj.member1 = 5;
}

Malgré cette restriction, C++ offre un mécanisme appelé fonctions amies qui peut contourner le contrôle d'accès habituel et opérer sur les données privées et protégées d'une classe.

Une classe amie est un concept similaire, permettant à une classe entière d'agir comme une amie. Les deux fonctionnalités sont des outils puissants lorsqu'elles sont utilisées judicieusement, améliorant l'encapsulation sans compromettre la flexibilité.

---

Fonction amie en C++

Une fonction amie peut lire et modifier les membres privés et protégés d'une classe. Elle est déclarée avec le mot-clé friend à l'intérieur de la définition de la classe.

class NomClasse {
    // ...
    friend typeRetour nomFonction(arguments);
    // ...
}

---

Exemple 1 : Fonction amie de base

// Programme C++ pour démontrer le fonctionnement de la fonction amie
#include <iostream>
using namespace std;

class Distance {
private:
    int meter;
    // fonction amie
    friend int addFive(Distance);
public:
    Distance() : meter(0) {}
};

// définition de la fonction amie
int addFive(Distance d) {
    // accès aux membres privés depuis la fonction amie
    d.meter += 5;
    return d.meter;
}

int main() {
    Distance D;
    cout << "Distance : " << addFive(D);
    return 0;
}

Sortie

Distance : 5

La fonction addFive() démontre qu'une fonction amie peut accéder librement au champ privé meter. Bien que cet exemple soit simple, il illustre l'idée centrale des fonctions amies.

---

Exemple 2 : Opération sur deux classes

// Addition des membres de deux classes différentes en utilisant des fonctions amies
#include <iostream>
using namespace std;

// déclaration anticipée
class ClassB;

class ClassA {
public:
    // constructeur pour initialiser numA à 12
    ClassA() : numA(12) {}
private:
    int numA;
    // déclaration de fonction amie
    friend int add(ClassA, ClassB);
};

class ClassB {
public:
    // constructeur pour initialiser numB à 1
    ClassB() : numB(1) {}
private:
    int numB;
    // déclaration de fonction amie
    friend int add(ClassA, ClassB);
};

// accès aux membres des deux classes
int add(ClassA objectA, ClassB objectB) {
    return (objectA.numA + objectB.numB);
}

int main() {
    ClassA objectA;
    ClassB objectB;
    cout << "Somme : " << add(objectA, objectB);
    return 0;
}

Sortie

Somme : 13

Dans ce programme, à la fois ClassA et ClassB déclarent la fonction add() comme amie. Cela accorde à la fonction l'accès aux données privées des deux classes, permettant la somme de numA et numB.

Notez que la déclaration amie dans ClassA référence ClassB avant qu'elle ne soit définie. Une déclaration anticipée class ClassB; résout cette dépendance.

---

Classe amie en C++

Déclarer une classe entière comme amie donne à toutes ses fonctions membres l'accès aux membres privés et protégés de la classe hôte. La syntaxe est simple :

class ClassB;
class ClassA {
    // ClassB est une classe amie de ClassA
    friend class ClassB;
    // ...
}
class ClassB {
    // ...
}

Puisque ClassB est une amie de ClassA, toute méthode à l'intérieur de ClassB peut librement lire ou modifier les données privées de ClassA. L'inverse n'est pas vrai ; ClassA ne peut pas accéder aux membres privés de ClassB à moins qu'elle ne déclare ClassB comme amie.

---

Exemple 3 : Classe amie en action

// Programme C++ pour démontrer le fonctionnement de la classe amie
#include <iostream>
using namespace std;

// déclaration anticipée
class ClassB;

class ClassA {
private:
    int numA;
    // déclaration de classe amie
    friend class ClassB;
public:
    // constructeur pour initialiser numA à 12
    ClassA() : numA(12) {}
};

class ClassB {
private:
    int numB;
public:
    // constructeur pour initialiser numB à 1
    ClassB() : numB(1) {}
    // fonction membre pour ajouter numA de ClassA et numB de ClassB
    int add() {
        ClassA objectA;
        return objectA.numA + numB;
    }
};

int main() {
    ClassB objectB;
    cout << "Somme : " << objectB.add();
    return 0;
}

Sortie

Somme : 13

La méthode add() dans ClassB peut accéder au membre privé numA de ClassA car ClassA a déclaré ClassB comme amie. Cet exemple montre comment les classes amies permettent une coopération étroite tout en préservant l'encapsulation.

Dans l'ensemble, les fonctions amies et classes amies sont des outils précieux en C++ quand vous avez besoin d'un accès contrôlé à travers les frontières de classes. Utilisez-les avec parcimonie et seulement quand la conception bénéficie de telles exceptions aux règles d'accès habituelles.