C++ Friend-Funktion und Friend-Klassen

C++ Friend-Funktion und Friend-Klassen

In diesem Tutorial lernen wir anhand von Beispielen, Friend-Funktionen und Friend-Klassen in C++ zu erstellen.

Das Verbergen von Daten ist ein grundlegendes Konzept der objektorientierten Programmierung. Es schränkt den Zugriff privater Mitglieder von außerhalb der Klasse ein.

Ebenso kann auf geschützte Member nur von abgeleiteten Klassen zugegriffen werden und sie sind von außen nicht zugänglich. Zum Beispiel

class MyClass {
    private:
        int member1;
}

int main() {
    MyClass obj;

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

Allerdings gibt es in C++ eine Funktion namens Friend Functions die diese Regel brechen und uns den Zugriff auf Elementfunktionen von außerhalb der Klasse ermöglichen.

Ebenso gibt es eine Freundesklasse auch, was wir später in diesem Tutorial lernen werden.

---

friend-Funktion in C++

Eine Freundschaftsfunktion auf privat zugreifen kann und geschützt Daten einer Klasse. Wir deklarieren eine Friend-Funktion mit friend Schlüsselwort innerhalb des Hauptteils der Klasse.

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

---

Beispiel 1:Funktionsweise der Friend-Funktion

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

Ausgabe

Distance: 5

Hier, addFive() ist eine Freundefunktion, die sowohl privat zugreifen kann und öffentlich Datenmitglieder.

Obwohl dieses Beispiel uns eine Vorstellung vom Konzept einer Freundesfunktion gibt, zeigt es keinen sinnvollen Nutzen.

Eine sinnvollere Verwendung wäre die Bearbeitung von Objekten zweier unterschiedlicher Klassen. Da kann die Freundesfunktion sehr hilfreich sein.

---

Beispiel 2:Mitglieder von zwei verschiedenen Klassen hinzufügen

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

Ausgabe

Sum: 13

In diesem Programm ClassA und ClassB haben add() deklariert als Friend-Funktion. Somit kann diese Funktion privat zugreifen Daten beider Klassen.

Eine Sache, die hier zu beachten ist, ist die Freundschaftsfunktion in ClassA verwendet den ClassB . Wir haben jedoch ClassB nicht definiert an dieser Stelle.

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

Damit dies funktioniert, benötigen wir eine Vorwärtsdeklaration von ClassB in unserem Programm.

// forward declaration
class ClassB;

---

Friend-Klasse in C++

Wir können auch eine Friend-Klasse in C++ mit dem friend verwenden Stichwort. Zum Beispiel

class ClassB;

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

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

Wenn eine Klasse als Friend-Klasse deklariert wird, werden alle Mitgliedsfunktionen der Friend-Klasse zu Friend-Funktionen.

Seit ClassB ist eine Freundesklasse, wir können auf alle Mitglieder von ClassA zugreifen von innen ClassB .

Wir können jedoch nicht auf Mitglieder von ClassB zugreifen aus ClassA . Das liegt daran, dass Freundschaftsbeziehungen in C++ nur gewährt, nicht genommen werden.

---

Beispiel 3:C++-Friend-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;
}

Ausgabe

Sum: 13

Hier, ClassB ist eine Freundesklasse von ClassA . Also ClassB hat Zugriff auf die Mitglieder von classA .

In ClassB haben wir eine Funktion add() erstellt die die Summe von numA zurückgibt und numB .

Seit ClassB eine Friend-Klasse ist, können wir Objekte von ClassA erstellen innerhalb von ClassB .