C++ vriend Functie en vriend Klassen

In deze tutorial leren we met behulp van voorbeelden vriendfuncties en vriendklassen te maken in C++.

Het verbergen van gegevens is een fundamenteel concept van objectgeoriënteerd programmeren. Het beperkt de toegang van privéleden van buiten de klas.

Evenzo zijn beveiligde leden alleen toegankelijk voor afgeleide klassen en zijn ze van buitenaf niet toegankelijk. Bijvoorbeeld,

class MyClass {
    private:
        int member1;
}

int main() {
    MyClass obj;

    // Error! Cannot access private members from here.
    obj.member1 = 5;
}

Er is echter een functie in C++ genaamd vriendfuncties die deze regel overtreden en ons toegang geven tot ledenfuncties van buiten de klas.

Evenzo is er een vriendenklasse ook, wat we later in deze tutorial zullen leren.

friend-functie in C++

Een vriendenfunctie heeft toegang tot de privé en beschermd gegevens van een klas. We declareren een vriendfunctie met behulp van de friend trefwoord in de hoofdtekst van de klas.

class className {
    ... .. ...
    friend returnType functionName(arguments);
    ... .. ...
}

Voorbeeld 1:Werking van vriend Functie

// 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;
}

Uitvoer

Distance: 5

Hier, addFive() is een vriendenfunctie die toegang heeft tot zowel privé en openbaar gegevens leden.

Hoewel dit voorbeeld ons een idee geeft van het concept van een vriendenfunctie, laat het geen zinvol gebruik zien.

Een zinvoller gebruik zou zijn om te werken met objecten van twee verschillende klassen. Dan kan de vriendenfunctie erg handig zijn.

Voorbeeld 2:Leden van twee verschillende klassen toevoegen

// 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;
}

Uitvoer

Sum: 13

In dit programma, ClassA en ClassB hebben verklaard add() als vriendenfunctie. Deze functie heeft dus toegang tot private gegevens van beide klassen.

Een ding om op te merken is de vriendenfunctie in ClassA gebruikt de ClassB . We hebben echter ClassB . niet gedefinieerd op dit punt.

// inside classA 
friend int add(ClassA, ClassB);

Om dit te laten werken, hebben we een voorwaartse declaratie van ClassB . nodig in ons programma.

// forward declaration
class ClassB;

vriendenklasse in C++

We kunnen ook een vriendenklasse in C++ gebruiken met de friend trefwoord. Bijvoorbeeld,

class ClassB;

class ClassA {
   // ClassB is a friend class of ClassA
   friend class ClassB;
   ... .. ...
}

class ClassB {
   ... .. ...
}

Wanneer een klasse tot vriendenklasse wordt verklaard, worden alle lidfuncties van de vriendenklasse vriendfuncties.

Sinds ClassB is een vriendenklasse, we hebben toegang tot alle leden van ClassA van binnenuit ClassB .

We hebben echter geen toegang tot leden van ClassB van binnenuit ClassA . Het is omdat een vriendschapsrelatie in C++ alleen wordt toegekend, niet wordt genomen.

Voorbeeld 3:C++ vriend klasse

// 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;
}

Uitvoer

Sum: 13

Hier, ClassB is een vriendenklas van ClassA . Dus ClassB heeft toegang tot de leden van classA .

In ClassB , we hebben een functie gemaakt add() dat geeft de som terug van numA en numB .

Sinds ClassB is een vriendenklasse, we kunnen objecten maken van ClassA binnenkant van ClassB .