C++ Friend Functies en Friend Classes: Toegangscontrole Beheersen

Deze tutorial demonstreert hoe friend functies en friend classes in C++ te declareren en gebruiken, met duidelijke voorbeelden.

Data hiding is een hoeksteen van objectgeoriënteerd programmeren, wat externe code voorkomt om direct toegang te krijgen tot de private leden van een klasse. Protected leden zijn alleen zichtbaar voor afgeleide klassen en blijven onbereikbaar van de buitenwereld.

Overweeg het volgende voorbeeld:

class MyClass { private: int member1; }; int main() { MyClass obj; // Fout! Kan private leden niet benaderen vanaf hier. obj.member1 = 5; }

Ondanks deze restricte, biedt C++ een mechanisme genaamd friend functies die de gebruikelijke toegangscontrole kan omzeilen en opereren op de private en protected data van een klasse.

Een friend class is een vergelijkbaar concept, wat een gehele klasse toestaat als friend te fungeren. Beide functies zijn krachtige hulpmiddelen wanneer ze terecht gebruikt worden, wat encapsulatie verbetert zonder flexibiliteit in te boeten.

Friend Functie in C++

friend functie kan de private en protected leden van een klasse lezen en wijzigen. Het wordt gedeclareerd met het friend sleutelwoord binnen de klassedefinitie.

class ClassName { // ... friend returnType functionName(arguments); // ... }

Voorbeeld 1: Basis Friend Functie

// C++ programma om de werking van friend functie te demonstreren #include <iostream> using namespace std; class Distance { private: int meter; // friend functie friend int addFive(Distance); public: Distance() : meter(0) {} }; // friend functie definitie int addFive(Distance d) { // benaderen private leden vanuit de friend functie d.meter += 5; return d.meter; } int main() { Distance D; cout << "Distance: " << addFive(D); return 0; }

Output

Distance: 5

De functie addFive() toont aan dat een friend functie vrij toegang heeft tot het private meter veld. Hoewel dit voorbeeld simpel is, illustreert het het kernidee van friend functies.

Voorbeeld 2: Opereren op Twee Klassen

// Leden van twee verschillende klassen optellen met friend functies #include <iostream> using namespace std; // forward declaratie class ClassB; class ClassA { public: // constructor om numA te initialiseren op 12 ClassA() : numA(12) {} private: int numA; // friend functie declaratie friend int add(ClassA, ClassB); }; class ClassB { public: // constructor om numB te initialiseren op 1 ClassB() : numB(1) {} private: int numB; // friend functie declaratie friend int add(ClassA, ClassB); }; // leden van beide klassen benaderen int add(ClassA objectA, ClassB objectB) { return (objectA.numA + objectB.numB); } int main() { ClassA objectA; ClassB objectB; cout << "Som: " << add(objectA, objectB); return 0; }

Output

Som: 13

In dit programma declareren zowel ClassA als ClassB de functie add() als friend. Dit geeft de functie toegang tot de private data van beide klassen, wat de som van numA en numB mogelijk maakt.

Let op dat de friend declaratie in ClassA verwijst naar ClassB voordat het gedefinieerd is. Een forward declaratie class ClassB; lost deze afhankelijkheid op.

Friend Class in C++

Het declareren van een gehele klasse als friend geeft al zijn lidfuncties toegang tot de private en protected leden van de gastheerklasse. De syntaxis is eenvoudig:

class ClassB; class ClassA { // ClassB is een friend class van ClassA friend class ClassB; // ... } class ClassB { // ... }

Omdat ClassB een friend is van ClassA, kan elke methode binnen ClassB vrij lezen of wijzigen van ClassA's private data. Het omgekeerde is niet waar; ClassA kan niet de private leden van ClassB benaderen tenzij het ClassB als friend declareert.

// C++ programma om de werking van friend class te demonstreren #include <iostream> using namespace std; // forward declaratie class ClassB; class ClassA { private: int numA; // friend class declaratie friend class ClassB; public: // constructor om numA te initialiseren op 12 ClassA() : numA(12) {} }; class ClassB { private: int numB; public: // constructor om numB te initialiseren op 1 ClassB() : numB(1) {} // lidfunctie om numA van ClassA en numB van ClassB op te tellen int add() { ClassA objectA; return objectA.numA + numB; } }; int main() { ClassB objectB; cout << "Som: " << objectB.add(); return 0; }

Som: 13