Wann sollten Sie 'friend' in C ++ verwenden?

Ich habe die C ++ - FAQ gelesen und war neugierig auf die friendErklärung. Ich persönlich habe es nie benutzt, aber ich bin daran interessiert, die Sprache zu erkunden.

Was ist ein gutes Beispiel für die Verwendung friend?

Wenn ich die FAQ etwas länger lese, mag ich die Idee, dass der << >>Operator als Freund dieser Klassen überlastet und hinzufügt. Ich bin mir jedoch nicht sicher, wie dies die Kapselung nicht unterbricht. Wann können diese Ausnahmen innerhalb der Strenge bleiben, die OOP ist?

Erstens (IMO) hören Sie nicht auf Leute, die sagen, dass dies friendnicht nützlich ist. Es ist nützlich. In vielen Situationen verfügen Sie über Objekte mit Daten oder Funktionen, die nicht öffentlich verfügbar sein sollen. Dies gilt insbesondere für große Codebasen mit vielen Autoren, die möglicherweise nur oberflächlich mit verschiedenen Bereichen vertraut sind.

Es gibt Alternativen zum Friend-Bezeichner, aber oft sind sie umständlich (konkrete Klassen auf CPP-Ebene / maskierte Typedefs) oder nicht narrensicher (Kommentare oder Konventionen für Funktionsnamen).

Auf die Antwort;

Der friendBezeichner ermöglicht der angegebenen Klasse den Zugriff auf geschützte Daten oder Funktionen innerhalb der Klasse, die die friend-Anweisung abgeben. Zum Beispiel kann im folgenden Code jeder ein Kind nach seinem Namen fragen, aber nur die Mutter und das Kind dürfen den Namen ändern.

Sie können dieses einfache Beispiel weiterführen, indem Sie eine komplexere Klasse wie ein Fenster betrachten. Sehr wahrscheinlich wird ein Fenster viele Funktions- / Datenelemente haben, die nicht öffentlich zugänglich sein sollten, aber von einer verwandten Klasse wie einem WindowManager benötigt werden.

class Child
{
//Mother class members can access the private parts of class Child.
friend class Mother;

public:

  string name( void );

protected:

  void setName( string newName );
};

Bei der Arbeit verwenden wir Freunde, um Code ausgiebig zu testen . Dies bedeutet, dass wir eine ordnungsgemäße Kapselung und Verstecken von Informationen für den Hauptanwendungscode bereitstellen können. Wir können aber auch einen separaten Testcode verwenden, der Freunde verwendet, um den internen Status und die Daten zum Testen zu überprüfen.

Es genügt zu sagen, dass ich das Schlüsselwort friend nicht als wesentlichen Bestandteil Ihres Designs verwenden würde.

Das friendSchlüsselwort hat eine Reihe von Verwendungsmöglichkeiten. Hier sind die beiden für mich sofort sichtbaren Verwendungen:

Freund Definition

Mit der Friend-Definition kann eine Funktion im Klassenbereich definiert werden. Die Funktion wird jedoch nicht als Elementfunktion, sondern als freie Funktion des umschließenden Namespace definiert und ist normalerweise nur für die argumentabhängige Suche sichtbar. Das macht es besonders nützlich für die Überlastung des Bedieners:

namespace utils {
    class f {
    private:
        typedef int int_type;
        int_type value;

    public:
        // let's assume it doesn't only need .value, but some
        // internal stuff.
        friend f operator+(f const& a, f const& b) {
            // name resolution finds names in class-scope. 
            // int_type is visible here.
            return f(a.value + b.value);
        }

        int getValue() const { return value; }
    };
}

int main() {
    utils::f a, b;
    std::cout << (a + b).getValue(); // valid
}

Private CRTP-Basisklasse

Manchmal müssen Sie feststellen, dass eine Richtlinie Zugriff auf die abgeleitete Klasse benötigt:

// possible policy used for flexible-class.
template<typename Derived>
struct Policy {
    void doSomething() {
        // casting this to Derived* requires us to see that we are a 
        // base-class of Derived.
        some_type const& t = static_cast<Derived*>(this)->getSomething();
    }
};

// note, derived privately
template<template<typename> class SomePolicy>
struct FlexibleClass : private SomePolicy<FlexibleClass> {
    // we derive privately, so the base-class wouldn't notice that, 
    // (even though it's the base itself!), so we need a friend declaration
    // to make the base a friend of us.
    friend class SomePolicy<FlexibleClass>;

    void doStuff() {
         // calls doSomething of the policy
         this->doSomething();
    }

    // will return useful information
    some_type getSomething();
};

In dieser Antwort finden Sie ein nicht erfundenes Beispiel dafür . Ein anderer Code, der dies verwendet, ist in dieser Antwort enthalten. Die CRTP-Basis wandelt diesen Zeiger um, um mithilfe von Datenelementzeigern auf Datenfelder der abgeleiteten Klasse zugreifen zu können.

@roo : Die Kapselung wird hier nicht unterbrochen, da die Klasse selbst vorschreibt, wer auf ihre privaten Mitglieder zugreifen darf. Die Kapselung würde nur dann unterbrochen, wenn dies von außerhalb der Klasse verursacht werden könnte, z. B. wenn Sie operator <<verkünden würden, dass ich ein Freund der Klasse bin foo.

friendersetzt die Verwendung von public, nicht die Verwendung von private!

Tatsächlich beantworten die C ++ - FAQ dies bereits .

Das kanonische Beispiel ist das Überladen des Operators <<. Eine weitere häufige Verwendung besteht darin, einem Helfer oder einer Administratorklasse den Zugriff auf Ihre Interna zu ermöglichen.

Hier sind einige Richtlinien, die ich über C ++ - Freunde gehört habe. Der letzte ist besonders denkwürdig.

• Ihre Freunde sind nicht die Freunde Ihres Kindes.
• Die Freunde Ihres Kindes sind nicht Ihre Freunde.
• Nur Freunde können Ihre privaten Teile berühren.

edit: Die FAQ etwas länger lesen Ich mag die Idee, dass der Operator << >> als Freund dieser Klassen überladen und hinzugefügt wird, bin mir jedoch nicht sicher, wie dies die Kapselung nicht unterbricht

Wie würde es die Kapselung brechen?

Sie unterbrechen die Kapselung, wenn Sie uneingeschränkten Zugriff auf ein Datenelement zulassen . Betrachten Sie die folgenden Klassen:

class c1 {
public:
  int x;
};

class c2 {
public:
  int foo();
private:
  int x;
};

class c3 {
  friend int foo();
private:
  int x;
};

c1ist offensichtlich nicht eingekapselt. Jeder kann es lesen und ändern x. Wir haben keine Möglichkeit, irgendeine Art von Zugangskontrolle durchzusetzen.

c2ist offensichtlich eingekapselt. Es gibt keinen öffentlichen Zugang zu x. Sie können lediglich die fooFunktion aufrufen , die eine sinnvolle Operation für die Klasse ausführt .

c3? Ist das weniger gekapselt? Ermöglicht es uneingeschränkten Zugriff auf x? Ermöglicht es den Zugriff auf unbekannte Funktionen?

Nein. Es ermöglicht genau einer Funktion, auf die privaten Mitglieder der Klasse zuzugreifen. Genau wie c2. Und genau wie c2die einzige Funktion, die Zugriff hat, ist nicht "eine zufällige, unbekannte Funktion", sondern "die in der Klassendefinition aufgeführte Funktion". Genauso c2können wir anhand der Klassendefinitionen eine vollständige Liste der Personen sehen, die Zugriff haben.

Wie genau ist das weniger gekapselt? Die gleiche Menge an Code hat Zugriff auf die privaten Mitglieder der Klasse. Und jeder , der Zugriff hat, ist in der Klassendefinition aufgeführt.

friendbricht die Kapselung nicht. Einige Java-Programmierer fühlen sich unwohl, denn wenn sie "OOP" sagen, meinen sie tatsächlich "Java". Wenn sie „Encapsulation“ sagen, meinen sie nicht, sondern „eine Java - Klasse , wo die einzigen Funktionen der Lage , den Zugang private Mitglieder, sind die Teilnehmer“ „private Mitglieder müssen vor willkürlichen Zugriffen geschützt werden“, auch wenn dies völliger Unsinn ist für mehrere Gründe .

Erstens ist es, wie bereits gezeigt, zu einschränkend. Es gibt keinen Grund, warum Freundmethoden nicht dasselbe tun dürfen.

Zweitens ist es nicht restriktiv genug . Betrachten Sie eine vierte Klasse:

class c4 {
public:
  int getx();
  void setx(int x);
private:
  int x;
};

Dies ist gemäß der oben genannten Java-Mentalität perfekt gekapselt. Und doch erlaubt es absolut jedem, x zu lesen und zu modifizieren . Wie macht das überhaupt Sinn? (Hinweis: Nicht)

Fazit: Bei der Kapselung geht es darum, steuern zu können, welche Funktionen auf private Mitglieder zugreifen können. Es geht nicht genau darum, wo sich die Definitionen dieser Funktionen befinden.

Eine weitere gängige Version von Andrews Beispiel ist das gefürchtete Code-Couplet

parent.addChild(child);
child.setParent(parent);

Anstatt sich Sorgen zu machen, ob beide Zeilen immer zusammen und in konsistenter Reihenfolge ausgeführt werden, können Sie die Methoden privat machen und eine Friend-Funktion haben, um die Konsistenz zu erzwingen:

class Parent;

class Object {
private:
    void setParent(Parent&);

    friend void addChild(Parent& parent, Object& child);
};

class Parent : public Object {
private:
     void addChild(Object& child);

     friend void addChild(Parent& parent, Object& child);
};

void addChild(Parent& parent, Object& child) {
    if( &parent == &child ){ 
        wetPants(); 
    }
    parent.addChild(child);
    child.setParent(parent);
}

Mit anderen Worten, Sie können die öffentlichen Schnittstellen kleiner halten und Invarianten erzwingen, die Klassen und Objekte in Friend-Funktionen überschneiden.

Sie steuern die Zugriffsrechte für Mitglieder und Funktionen mit privaten / geschützten / öffentlichen Rechten? Wenn also die Idee jeder dieser drei Ebenen klar ist, sollte klar sein, dass uns etwas fehlt ...

Die Deklaration eines Mitglieds / einer Funktion als geschützt ist beispielsweise ziemlich allgemein. Sie sagen, dass diese Funktion für alle unerreichbar ist (außer natürlich für ein geerbtes Kind). Aber was ist mit Ausnahmen? Mit jedem Sicherheitssystem können Sie eine Art "weiße Liste" haben, oder?

Mit Friend haben Sie die Flexibilität, eine solide Objektisolierung zu haben, aber es kann eine "Lücke" für Dinge geschaffen werden, die Sie für gerechtfertigt halten.

Ich denke, die Leute sagen, dass es nicht benötigt wird, weil es immer ein Design gibt, das ohne es auskommt. Ich denke, es ist ähnlich wie bei der Diskussion globaler Variablen: Sie sollten sie niemals verwenden. Es gibt immer einen Weg, auf sie zu verzichten. In Wirklichkeit sehen Sie jedoch Fälle, in denen dies der (fast) eleganteste Weg ist. Ich denke, das ist der gleiche Fall mit Freunden.

Es nützt nichts, außer dass Sie auf eine Mitgliedsvariable zugreifen können, ohne eine Einstellungsfunktion zu verwenden

Nun, das ist nicht genau die Art, es zu betrachten. Die Idee ist zu kontrollieren, wer auf etwas zugreifen kann, ob eine Einstellungsfunktion wenig damit zu tun hat oder nicht .

Ich fand einen praktischen Ort, um den Zugang von Freunden zu nutzen: Unittest von privaten Funktionen.

Friend ist praktisch, wenn Sie einen Container erstellen und einen Iterator für diese Klasse implementieren möchten.

Wir hatten ein interessantes Problem bei einer Firma, bei der ich zuvor gearbeitet habe, bei der wir Freunde für anständige Affekte eingesetzt haben. Ich habe in unserer Framework-Abteilung gearbeitet. Wir haben ein grundlegendes System auf Engine-Ebene über unser benutzerdefiniertes Betriebssystem erstellt. Intern hatten wir eine Klassenstruktur:

         Game
        /    \
 TwoPlayer  SinglePlayer

Alle diese Klassen waren Teil des Rahmens und wurden von unserem Team gepflegt. Die von der Firma produzierten Spiele wurden auf diesem Framework aufgebaut, das von einem der Games-Kinder stammt. Das Problem war, dass Game Schnittstellen zu verschiedenen Dingen hatte, auf die SinglePlayer und TwoPlayer Zugriff benötigen, die wir jedoch nicht außerhalb der Framework-Klassen verfügbar machen wollten. Die Lösung bestand darin, diese Schnittstellen privat zu machen und TwoPlayer und SinglePlayer über eine Freundschaft auf sie zuzugreifen.

Ehrlich gesagt hätte dieses ganze Problem durch eine bessere Implementierung unseres Systems gelöst werden können, aber wir waren an das gebunden, was wir hatten.

Die kurze Antwort wäre: Freund benutzen, wenn es sich tatsächlich verbessert Kapselung . Die Verbesserung der Lesbarkeit und Benutzerfreundlichkeit (Operatoren << und >> sind das kanonische Beispiel) ist ebenfalls ein guter Grund.

Beispiele für die Verbesserung der Kapselung sind Klassen, die speziell für die Zusammenarbeit mit den Interna anderer Klassen entwickelt wurden (Testklassen fallen mir ein).

Der Schöpfer von C ++ sagt, dass dies kein Kapselungsprinzip vermittelt, und ich werde ihn zitieren:

Verstößt "Freund" gegen die Kapselung? Nein, tut es nicht. "Freund" ist genau wie die Mitgliedschaft ein expliziter Mechanismus, um Zugriff zu gewähren. Sie können sich (in einem standardkonformen Programm) keinen Zugriff auf eine Klasse gewähren, ohne deren Quelle zu ändern.

Ist mehr als klar ...

Eine andere Verwendung: Freund (+ virtuelle Vererbung) kann verwendet werden, um das Ableiten von einer Klasse zu vermeiden (auch bekannt als "eine Klasse unteraktivierbar machen") => 1 , 2

Ab 2 :

 class Fred;

 class FredBase {
 private:
   friend class Fred;
   FredBase() { }
 };

 class Fred : private virtual FredBase {
 public:
   ...
 }; 

Um TDD oft zu machen, habe ich in C ++ das Schlüsselwort 'friend' verwendet.

Kann ein Freund alles über mich wissen?

Aktualisiert: Ich habe diese wertvolle Antwort zum Schlüsselwort "Freund" von der Bjarne Stroustrup-Website gefunden .

"Freund" ist genau wie die Mitgliedschaft ein expliziter Mechanismus, um Zugriff zu gewähren.

Sie müssen sehr vorsichtig sein, wann / wo Sie das friendSchlüsselwort verwenden, und wie Sie habe ich es sehr selten verwendet. Nachfolgend finden Sie einige Hinweise zur Verwendung friendund zu den Alternativen.

Angenommen, Sie möchten zwei Objekte vergleichen, um festzustellen, ob sie gleich sind. Sie könnten entweder:

• Verwenden Sie Accessor-Methoden, um den Vergleich durchzuführen (überprüfen Sie jeden Ivar und bestimmen Sie die Gleichheit).
• Sie können auch direkt auf alle Mitglieder zugreifen, indem Sie sie öffentlich machen.

Das Problem mit der ersten Option ist, dass dies eine Menge Accessoren sein können, die (etwas) langsamer als der direkte variable Zugriff, schwerer zu lesen und umständlich sind. Das Problem beim zweiten Ansatz besteht darin, dass Sie die Kapselung vollständig unterbrechen.

Was schön wäre, wäre, wenn wir eine externe Funktion definieren könnten, die immer noch Zugriff auf die privaten Mitglieder einer Klasse erhalten könnte. Wir können dies mit dem friendSchlüsselwort tun :

class Beer {
public:
    friend bool equal(Beer a, Beer b);
private:
    // ...
};

Das Verfahren equal(Beer, Beer)hat nun direkten Zugriff auf aund b‚s private Mitglieder (was sein kann char *brand, float percentAlcoholusw. Dies ist ein ziemlich konstruiertes Beispiel, Sie früher anwenden würde , friendum eine überladene == operator, aber wir werden auf das bekommen.

Ein paar Dinge zu beachten:

• A friendist KEINE Mitgliedsfunktion der Klasse
• Es ist eine gewöhnliche Funktion mit besonderem Zugang zu den privaten Mitgliedern der Klasse
• Ersetzen Sie nicht alle Accessoren und Mutatoren durch Freunde (Sie können auch alles machen public!)
• Freundschaft ist nicht wechselseitig
• Freundschaft ist nicht transitiv
• Freundschaft wird nicht vererbt
• Oder, wie in den C ++ - FAQ erklärt : "Nur weil ich Ihnen Freundschaftszugriff auf mich erteile, gewähren Sie Ihren Kindern nicht automatisch Zugriff auf mich, gewähren Ihren Freunden nicht automatisch Zugriff auf mich und gewähren mir nicht automatisch Zugriff auf mich." . "

Ich benutze friendses nur dann wirklich, wenn es viel schwieriger ist, es andersherum zu machen. Als weiteres Beispiel sind viele Vektor - Mathematik - Funktionen oft erstellt friendsaufgrund der Interoperabilität Mat2x2, Mat3x3, Mat4x4, Vec2, Vec3, Vec4, etc. Und es ist nur so viel einfacher , Freunde zu sein, anstatt zu haben Accessoren überall zu nutzen. Wie bereits erwähnt, friendist es oft nützlich, wenn es auf das <<(sehr praktisch zum Debuggen) >>und möglicherweise auf den ==Operator angewendet wird, kann aber auch für Folgendes verwendet werden:

class Birds {
public:
    friend Birds operator +(Birds, Birds);
private:
    int numberInFlock;
};


Birds operator +(Birds b1, Birds b2) {
    Birds temp;
    temp.numberInFlock = b1.numberInFlock + b2.numberInFlock;
    return temp;
}

Wie gesagt, ich benutze es nicht friendsehr oft, aber hin und wieder ist es genau das, was du brauchst. Hoffe das hilft!

In Bezug auf Operator << und Operator >> gibt es keinen guten Grund, diese Operatoren zu Freunden zu machen. Es ist wahr, dass sie keine Mitgliedsfunktionen sein sollten, aber sie müssen auch keine Freunde sein.

Am besten erstellen Sie öffentliche Druck- (ostream &) und Lesefunktionen (istream &). Schreiben Sie dann den Operator << und den Operator >> in Bezug auf diese Funktionen. Dies bietet den zusätzlichen Vorteil, dass Sie diese Funktionen virtuell gestalten können, was eine virtuelle Serialisierung ermöglicht.

Ich verwende das Freund-Schlüsselwort nur, um geschützte Funktionen zu testen. Einige werden sagen, dass Sie geschützte Funktionen nicht testen sollten. Ich finde dieses Tool jedoch sehr nützlich, wenn ich neue Funktionen hinzufüge.

Ich verwende das Schlüsselwort jedoch nicht direkt in den Klassendeklarationen, sondern verwende einen raffinierten Template-Hack, um dies zu erreichen:

template<typename T>
class FriendIdentity {
public:
  typedef T me;
};

/**
 * A class to get access to protected stuff in unittests. Don't use
 * directly, use friendMe() instead.
 */
template<class ToFriend, typename ParentClass>
class Friender: public ParentClass
{
public:
  Friender() {}
  virtual ~Friender() {}
private:
// MSVC != GCC
#ifdef _MSC_VER
  friend ToFriend;
#else
  friend class FriendIdentity<ToFriend>::me;
#endif
};

/**
 * Gives access to protected variables/functions in unittests.
 * Usage: <code>friendMe(this, someprotectedobject).someProtectedMethod();</code>
 */
template<typename Tester, typename ParentClass>
Friender<Tester, ParentClass> & 
friendMe(Tester * me, ParentClass & instance)
{
    return (Friender<Tester, ParentClass> &)(instance);
}

Dies ermöglicht mir Folgendes:

friendMe(this, someClassInstance).someProtectedFunction();

Funktioniert mindestens mit GCC und MSVC.

In C ++ ist das Schlüsselwort "friend" beim Überladen von Operatoren und beim Erstellen von Bridge hilfreich.

1.) Friend-Schlüsselwort beim Überladen von Operatoren:
Beispiel für das Überladen von Operatoren ist: Angenommen, wir haben eine Klasse "Point" mit zwei Gleitkommavariablen
"x" (für x-Koordinate) und "y" (für y-Koordinate). Jetzt müssen wir überladen "<<"(Extraktionsoperator), so dass, wenn wir aufrufen"cout << pointobj" die x- und y-Koordinate gedruckt wird (wobei pointobj ein Objekt der Klasse Point ist). Dazu haben wir zwei Möglichkeiten:

   1.Überladen Sie die Funktion "operator << ()" in der Klasse "ostream".
   2.Überladen Sie die Funktion "operator << ()" in der Klasse "Point".

   1.Verwenden des ostream-Objekts cout.As: cout.operator << (Pointobj) (Form ostream class). 
   2. Anruf ohne Objekt. As: Operator << (cout, Pointobj) (aus der Point-Klasse).

Weil wir eine Überladung in der Point-Klasse implementiert haben. Um diese Funktion ohne Objekt aufzurufen, müssen wir ein "friend"Schlüsselwort hinzufügen, da wir eine Friend-Funktion ohne Objekt aufrufen können. Jetzt lautet die Funktionsdeklaration wie folgt:
"friend ostream &operator<<(ostream &cout, Point &pointobj);"

2.) Schlüsselwort Friend bei der Erstellung einer Brücke:
Angenommen, wir müssen eine Funktion erstellen, in der wir auf ein privates Mitglied von zwei oder mehr Klassen zugreifen müssen (im Allgemeinen als "Brücke" bezeichnet). Vorgehensweise:
Um auf ein privates Mitglied einer Klasse zugreifen zu können, sollte es Mitglied dieser Klasse sein. Um nun auf ein privates Mitglied einer anderen Klasse zugreifen zu können, sollte jede Klasse diese Funktion als Freundfunktion deklarieren. Beispiel: Angenommen, es gibt zwei Klassen A und B. Eine Funktion "funcBridge()"möchte auf ein privates Mitglied beider Klassen zugreifen. Dann sollten beide Klassen deklarieren "funcBridge()"als:
friend return_type funcBridge(A &a_obj, B & b_obj);

Ich denke, dies würde helfen, das Schlüsselwort "Freund" zu verstehen.

Wie die Referenz für die Erklärung eines Freundes sagt:

Die Freunddeklaration wird in einem Klassenkörper angezeigt und gewährt einer Funktion oder einer anderen Klasse Zugriff auf private und geschützte Mitglieder der Klasse, in der die Freunddeklaration angezeigt wird.

Nur zur Erinnerung, es gibt technische Fehler in einigen der Antworten, die besagen, dass friendnur geschützte Mitglieder besucht werden können.

Das Baumbeispiel ist ein ziemlich gutes Beispiel: Ein Objekt in einer anderen Klasse implementieren zu lassen, ohne eine Vererbungsbeziehung zu haben.

Vielleicht brauchen Sie es auch, um einen Konstruktor zu schützen und die Leute zu zwingen, Ihre "Freund" -Fabrik zu benutzen.

... Ok, ehrlich gesagt kannst du ohne leben.

Um TDD oft zu machen, habe ich in C ++ das Schlüsselwort 'friend' verwendet.
Kann ein Freund alles über mich wissen?

Nein, es ist nur eine Einbahnstraße: `(

Eine spezielle Instanz, die ich verwende, friendist das Erstellen von Singleton- Klassen. Mit dem friendSchlüsselwort kann ich eine Accessor-Funktion erstellen, die präziser ist als immer eine "GetInstance ()" - Methode für die Klasse.

/////////////////////////
// Header file
class MySingleton
{
private:
    // Private c-tor for Singleton pattern
    MySingleton() {}

    friend MySingleton& GetMySingleton();
}

// Accessor function - less verbose than having a "GetInstance()"
//   static function on the class
MySingleton& GetMySingleton();


/////////////////////////
// Implementation file
MySingleton& GetMySingleton()
{
    static MySingleton theInstance;
    return theInstance;
}

Friend-Funktionen und -Klassen bieten direkten Zugriff auf private und geschützte Mitglieder der Klasse, um zu vermeiden, dass die Kapselung im allgemeinen Fall unterbrochen wird. Die meiste Verwendung erfolgt mit ostream: Wir möchten Folgendes eingeben können:

Point p;
cout << p;

Dies kann jedoch den Zugriff auf die privaten Daten von Point erfordern, daher definieren wir den überladenen Operator

friend ostream& operator<<(ostream& output, const Point& p);

Es gibt jedoch offensichtliche Auswirkungen auf die Verkapselung. Erstens hat die Freundesklasse oder -funktion jetzt vollen Zugriff auf ALLE Mitglieder der Klasse, auch auf diejenigen, die nicht ihren Anforderungen entsprechen. Zweitens sind die Implementierungen der Klasse und des Freundes jetzt so eng miteinander verbunden, dass eine interne Änderung in der Klasse den Freund beschädigen kann.

Wenn Sie den Freund als Erweiterung der Klasse betrachten, ist dies logischerweise kein Problem. Aber warum war es in diesem Fall überhaupt notwendig, den Freund auszuspießen?

Um dasselbe zu erreichen, was "Freunde" vorgeben zu erreichen, ohne jedoch die Kapselung zu unterbrechen, kann man dies tun:

class A
{
public:
    void need_your_data(B & myBuddy)
    {
        myBuddy.take_this_name(name_);
    }
private:
    string name_;
};

class B
{
public:
    void print_buddy_name(A & myBuddy)
    {
        myBuddy.need_your_data(*this);
    }
    void take_this_name(const string & name)
    {
        cout << name;
    }
}; 

Die Kapselung ist nicht unterbrochen, Klasse B hat keinen Zugriff auf die interne Implementierung in A, aber das Ergebnis ist das gleiche, als hätten wir B als Freund von A deklariert. Der Compiler optimiert die Funktionsaufrufe, sodass dies dasselbe ergibt Anweisungen als direkter Zugriff.

Ich denke, die Verwendung von "Freund" ist einfach eine Abkürzung mit fraglichem Nutzen, aber bestimmten Kosten.

Dies ist möglicherweise keine tatsächliche Anwendungsfallsituation, kann jedoch dazu beitragen, die Verwendung von Freunden zwischen Klassen zu veranschaulichen.

Das Clubhaus

class ClubHouse {
public:
    friend class VIPMember; // VIP Members Have Full Access To Class
private:
    unsigned nonMembers_;
    unsigned paidMembers_;
    unsigned vipMembers;

    std::vector<Member> members_;
public:
    ClubHouse() : nonMembers_(0), paidMembers_(0), vipMembers(0) {}

    addMember( const Member& member ) { // ...code }   
    void updateMembership( unsigned memberID, Member::MembershipType type ) { // ...code }
    Amenity getAmenity( unsigned memberID ) { // ...code }

protected:
    void joinVIPEvent( unsigned memberID ) { // ...code }

}; // ClubHouse

Die Mitgliederklasse

class Member {
public:
    enum MemberShipType {
        NON_MEMBER_PAID_EVENT,   // Single Event Paid (At Door)
        PAID_MEMBERSHIP,         // Monthly - Yearly Subscription
        VIP_MEMBERSHIP,          // Highest Possible Membership
    }; // MemberShipType

protected:
    MemberShipType type_;
    unsigned id_;
    Amenity amenity_;
public:
    Member( unsigned id, MemberShipType type ) : id_(id), type_(type) {}
    virtual ~Member(){}
    unsigned getId() const { return id_; }
    MemberShipType getType() const { return type_; }
    virtual void getAmenityFromClubHouse() = 0       
};

class NonMember : public Member {
public:
   explicit NonMember( unsigned id ) : Member( id, MemberShipType::NON_MEMBER_PAID_EVENT ) {}   

   void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class PaidMember : public Member {
public:
    explicit PaidMember( unsigned id ) : Member( id, MemberShipType::PAID_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class VIPMember : public Member {
public:
    friend class ClubHouse;
public:
    explicit VIPMember( unsigned id ) : Member( id, MemberShipType::VIP_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }

    void attendVIPEvent() {
        ClubHouse::joinVIPEvent( this->id );
    }
};

Ausstattung

class Amenity{};

Wenn Sie sich hier die Beziehung dieser Klassen ansehen; Das ClubHouse bietet verschiedene Arten von Mitgliedschaften und Zugang zu Mitgliedern. Die Mitglieder werden alle von einer Super- oder Basisklasse abgeleitet, da sie alle eine gemeinsame ID und einen Aufzählungstyp gemeinsam haben und externe Klassen über Zugriffsfunktionen in der Basisklasse auf ihre IDs und Typen zugreifen können.

Aufgrund dieser Art von Hierarchie der Mitglieder und ihrer abgeleiteten Klassen und ihrer Beziehung zur ClubHouse-Klasse ist die VIPMember-Klasse die einzige der abgeleiteten Klassen, die "besondere Berechtigungen" besitzt. Die Basisklasse und die anderen beiden abgeleiteten Klassen können nicht auf die joinVIPEvent () -Methode des ClubHouse zugreifen. Die VIP-Mitgliedsklasse verfügt jedoch über dieses Privileg, als hätte sie vollständigen Zugriff auf dieses Ereignis.

Mit dem VIPMember und dem ClubHouse ist es also eine Einbahnstraße in beide Richtungen, in der die anderen Mitgliederklassen begrenzt sind.

Bei der Implementierung von Baumalgorithmen für Klassen hatte der Framework-Code, den der Professor uns gegeben hatte, die Baumklasse als Freund der Knotenklasse.

Es nützt nichts, außer dass Sie auf eine Mitgliedsvariable zugreifen können, ohne eine Einstellungsfunktion zu verwenden.

Sie können Freundschaft verwenden, wenn verschiedene Klassen (die nicht voneinander erben) private oder geschützte Mitglieder der anderen Klasse verwenden.

Typische Anwendungsfälle von Friend-Funktionen sind Vorgänge, die zwischen zwei verschiedenen Klassen ausgeführt werden, die auf private oder geschützte Mitglieder beider zugreifen.

von http://www.cplusplus.com/doc/tutorial/inheritance/ .

Sie können dieses Beispiel sehen, in dem eine Nichtmitgliedsmethode auf die privaten Mitglieder einer Klasse zugreift. Diese Methode muss in dieser Klasse als Freund der Klasse deklariert werden.

// friend functions
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    Rectangle() {}
    Rectangle (int x, int y) : width(x), height(y) {}
    int area() {return width * height;}
    friend Rectangle duplicate (const Rectangle&);
};

Rectangle duplicate (const Rectangle& param)
{
  Rectangle res;
  res.width = param.width*2;
  res.height = param.height*2;
  return res;
}

int main () {
  Rectangle foo;
  Rectangle bar (2,3);
  foo = duplicate (bar);
  cout << foo.area() << '\n';
  return 0;
}

Wahrscheinlich habe ich etwas von den obigen Antworten verpasst, aber ein weiteres wichtiges Konzept bei der Kapselung ist das Verstecken der Implementierung. Das Reduzieren des Zugriffs auf private Datenelemente (die Implementierungsdetails einer Klasse) ermöglicht später eine wesentlich einfachere Änderung des Codes. Wenn ein Freund direkt auf die privaten Daten zugreift und alle Änderungen an den Implementierungsdatenfeldern (privaten Daten) vorgenommen werden, wird der Code, der auf diese Daten zugreift, unterbrochen. Die Verwendung von Zugriffsmethoden beseitigt dies größtenteils. Ziemlich wichtig würde ich denken.

Sie können die strengsten und reinsten OOP-Prinzipien einhalten und sicherstellen, dass keine Datenelemente für eine Klasse über Zugriffsmethoden verfügen, sodass alle Objekte die einzigen sein müssen , die über ihre Daten Bescheid wissen können. Die einzige Möglichkeit, auf sie zu reagieren, sind indirekte Nachrichten , sind . dh Methoden.

Aber auch C # hat ein internes Sichtbarkeitsschlüsselwort und Java hat für einige Dinge die Standardzugriffsfähigkeit auf Paketebene . C ++ kommt dem OOP-Ideal tatsächlich näher, indem der Kompromiss der Sichtbarkeit in eine Klasse minimiert wird, indem genau angegeben wird , welche andere Klasse und nur andere Klassen in sie hinein sehen können.

Ich benutze C ++ nicht wirklich, aber wenn C # Freunde hätte, würde ich das anstelle des Assembly-globalen internen Modifikators tun , den ich tatsächlich oft benutze. Die Kapselung wird nicht wirklich unterbrochen, da die Bereitstellungseinheit in .NET ist eine Montage.

Aber dann gibt es das InternalsVisibleTo- Attribut (otherAssembly), das sich wie ein montageübergreifender Freundschaftsmechanismus verhält . Microsoft verwendet dies für visuelle Designer- Assemblys.

Freunde sind auch nützlich für Rückrufe. Sie können Rückrufe als statische Methoden implementieren

class MyFoo
{
private:
    static void callback(void * data, void * clientData);
    void localCallback();
    ...
};

wo callbackAnrufe localCallbackintern und dieclientData hat Ihre Instanz drin. Meiner Meinung nach,

oder...

class MyFoo
{
    friend void callback(void * data, void * callData);
    void localCallback();
}

Dies ermöglicht es dem Freund, rein im cpp als c-artige Funktion definiert zu werden und die Klasse nicht zu überladen.

Ebenso ist ein Muster, das ich sehr oft gesehen habe, alles wirklich zu sagen privaten Mitglieder einer Klasse in eine andere Klasse zu setzen, die im Header deklariert, im cpp definiert und befreundet ist. Dies ermöglicht es dem Codierer, einen Großteil der Komplexität und internen Arbeitsweise der Klasse vor dem Benutzer des Headers zu verbergen.

In der Kopfzeile:

class MyFooPrivate;
class MyFoo
{
    friend class MyFooPrivate;
public:
    MyFoo();
    // Public stuff
private:
    MyFooPrivate _private;
    // Other private members as needed
};

In der cpp,

class MyFooPrivate
{
public:
   MyFoo *owner;
   // Your complexity here
};

MyFoo::MyFoo()
{
    this->_private->owner = this;
}

Es wird einfacher, Dinge zu verbergen, die der Downstream nicht so sehen muss.