Fonctions et classes amies

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 32 sur 104.

Parfois, une fonction ou une classe extérieure à votre classe doit accéder à ses membres privés. Plutôt que de rendre ces membres publics, C++ fournit le mot-clé friend pour accorder un accès sélectif tout en préservant l’encapsulation.

Une fonction amie est déclarée à l’intérieur d’une classe, mais n’est pas membre de cette classe. Elle peut accéder aux membres privés et protégés de la classe :

class Box {
    double width;
    
public:
    Box(double w) : width(w) {}
    
    // Déclare printWidth comme friend
    friend void printWidth(const Box& b);
};

// Définition de la fonction friend - PAS une fonction membre
void printWidth(const Box& b) {
    std::cout << b.width;    // Peut accéder au membre privé
}

Notez que printWidth est défini en dehors de la classe, sans l’opérateur de résolution de portée. Il s’agit d’une fonction ordinaire qui bénéficie par hasard de privilèges d’accès particuliers.

Vous pouvez également déclarer toute une classe comme amie, en accordant à toutes ses fonctions membres l’accès aux membres privés :

class Engine {
    int horsepower;
    
    friend class Mechanic;    // Mechanic peut accéder aux membres privés
    
public:
    Engine(int hp) : horsepower(hp) {}
};

class Mechanic {
public:
    void diagnose(const Engine& e) {
        std::cout << e.horsepower;    // Autorisé - Mechanic est un friend
    }
};

L’amitié n’est pas réciproque : si Engine déclare Mechanic comme ami, Mechanic peut accéder aux membres privés de Engine, mais pas l’inverse. Utilisez les amis avec parcimonie, car ils créent un couplage étroit entre les classes. Ils sont particulièrement utiles pour la surcharge d’opérateurs et les fonctions auxiliaires étroitement liées.

Défi

Facile

Construisons un système de messagerie sécurisé dans lequel une classe MessageReader a besoin d'un accès spécial pour lire les messages chiffrés stockés dans une classe SecureMessage. C'est un scénario idéal pour utiliser des fonctions amies et des classes amies.

Vous allez créer deux fichiers pour organiser votre code :

SecureMessage.h : définissez une classe SecureMessage qui stocke des données de message privées et accorde un accès sélectif aux entités de confiance. Votre classe doit comporter :
- Membres privés : content (chaîne) et secretKey (entier)
- Un constructeur qui prend le contenu et la clé secrète
- Déclarer MessageReader comme classe amie afin qu'elle puisse accéder aux membres privés
- Déclarer une fonction amie decryptMessage(const SecureMessage& msg, int key) qui renvoie le contenu uniquement si la clé fournie correspond à la clé secrète, et renvoie sinon "Access Denied"
Définissez ensuite la classe MessageReader dans le même fichier d'en-tête :
- Une méthode readContent(const SecureMessage& msg) qui accède directement au content privé du message et le renvoie
- Une méthode verifyKey(const SecureMessage& msg, int key) qui vérifie si la clé fournie correspond au secretKey du message et renvoie "Valid" ou "Invalid"
Enfin, définissez la fonction amie decryptMessage après les classes.
main.cpp : démontrez le fonctionnement des fonctions amies et des classes amies. Lisez le contenu d'un message, une clé secrète et une clé de test depuis l'entrée (chacun sur une ligne distincte), puis :
- Créez un objet SecureMessage avec le contenu et la clé secrète
- Créez un objet MessageReader
- Affichez "Reader access: <content>" en utilisant la méthode readContent() du lecteur
- Affichez "Key verification: <result>" en utilisant verifyKey() avec la clé de test
- Affichez "Decrypt with test key: <result>" en utilisant la fonction amie avec la clé de test
- Affichez "Decrypt with correct key: <result>" en utilisant la fonction amie avec la clé secrète d'origine

N'oubliez pas que les fonctions amies sont définies en dehors de la classe, sans l'opérateur de résolution de portée : ce sont des fonctions ordinaires bénéficiant de privilèges d'accès spéciaux. La classe MessageReader, étant une amie, peut accéder directement aux membres privés de SecureMessage dans toutes ses méthodes.

Convertissez les entrées de clé de chaînes en entiers à l'aide de std::stoi(). Incluez votre fichier d'en-tête dans main.cpp à l'aide de #include "SecureMessage.h".

Essayez vous-même

#include <iostream>
#include <string>
#include "SecureMessage.h"
using namespace std;

int main() {
    // Lire l'entrée
    string messageContent;
    string secretKeyStr;
    string testKeyStr;
    
    getline(cin, messageContent);
    getline(cin, secretKeyStr);
    getline(cin, testKeyStr);
    
    int secretKey = stoi(secretKeyStr);
    int testKey = stoi(testKeyStr);
    
    // TODO: Créer un SecureMessage avec le contenu et la clé secrète
    
    // TODO: Créer un objet MessageReader
    
    // TODO: Print "Reader access: <content>" using readContent()
    
    // TODO: Print "Key verification: <result>" using verifyKey() with test key
    
    // TODO: Print "Decrypt with test key: <result>" using decryptMessage with test key
    
    // TODO: Print "Decrypt with correct key: <result>" using decryptMessage with secret key
    
    return 0;
}