Wann sollten Sie die Verwendung von 'Freund' in C++?

Bei der Arbeit wir verwenden Freunde zum testen von codeausgiebig. Es bedeutet, dass wir die richtige Kapselung und information hiding für die wichtigsten Anwendungs-code. Aber auch wir können den separaten test-code, der verwendet Freunde zu inspizieren internen Zustand und Daten für Tests.

Genügt zu sagen, ich würde nicht mit dem Freund Schlüsselwort als ein wesentlicher Bestandteil Ihres Entwurfs.

InformationsquelleAutor der Antwort Daemin

@roo: Verkapselung ist nicht gebrochen, weil hier die Klasse selbst bestimmt, wer Zugriff auf deren private member. Die Kapselung würde nur gebrochen werden, wenn diese verursacht werden könnten, die von außerhalb der Klasse, z.B. wenn Ihr operator << würde verkünden "ich bin ein Freund der Klasse foo."

friend ersetzt die Verwendung von public nicht von private!

Eigentlich, der C++ FAQ Antworten zu diesem bereits.

InformationsquelleAutor der Antwort Konrad Rudolph

edit: das Lesen der faq ein bisschen länger, ich mag die Idee, die << >> operator überladen und das hinzufügen als Freund von diesen Klassen, jedoch bin ich nicht sicher, wie dieser nicht bricht Kapselung

Wie würden Sie es brechen Kapselung?

Brechen Sie die Kapselung, wenn Sie erlauben uneingeschränkte Zugriff auf ein Datenelement. 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;
};

c1 ist offensichtlich nicht gekapselt. Jeder kann Lesen und ändern x. Wir haben keine Möglichkeit, zu erzwingen, jede Art von access control.

c2 ist natürlich gekapselt. Es gibt keine öffentlichen Zugang zu x. Alles, was Sie tun können, ist rufen Sie die foo - Funktion, die führt einige sinnvolle operation auf der Klasse.

c3? Ist, dass weniger gekapselt? Ist die Möglichkeit einer uneingeschränkten Zugang zu x? Erlaubt es, unbekannte Funktionen zugreifen?

Nicht. Es ermöglicht präzise eine Funktion, die Zugriff auf private Mitglieder der Klasse. Wie c2 haben. Und genau wie c2die eine Funktion, die Zugriff hat, ist nicht "einige zufällige, unbekannte Funktion", sondern "die Funktion aufgeführt, die in der definition der Klasse". Wie c2 wir sehen können, einfach durch einen Blick auf die Klasse Definitionen, eine komplette Liste, wer Zugriff hat.

Also wie genau ist diese weniger gekapselt? Die gleiche Menge an code hat Zugriff auf die privaten Elemente der Klasse. Und jederder Zugang hat aufgeführt ist in der definition der Klasse.

friend nicht bricht Kapselung. Es macht einige Java-Menschen, Programmierer fühlen sich unwohl, weil, wenn Sie sagen, "OOP", die Sie tatsächlich bedeuten "Java". Wenn Sie sagen, "Kapselung", meinen Sie nicht, dass "private Mitglieder müssen geschützt werden, vor willkürlichen Zugriffen", aber "eine Java-Klasse, wo die einzigen Funktionen, die Zugriff auf private member, sind die Schüler", obwohl das völliger Blödsinn ist aus mehreren Gründen.

Zunächst wird, wie bereits gezeigt, ist es zu beschränken. Es gibt keinen Grund, warum friend-Methoden nicht erlaubt werden sollte, das gleiche zu tun.

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

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

Diese, entsprechend der oben erwähnten Java-Mentalität, ist vollkommen gekapselt.
Und doch erlaubt es das absolut jeder Lesen und ändern von x. Wie funktioniert das sogar Sinn machen? (Tipp: Es muss nicht)

Bottom line:
Kapselung ist über die Möglichkeit zu Steuern, welche Funktionen kann der Zugriff auf private Mitglieder. Es ist nicht über genau dort, wo die Definitionen dieser Funktionen befinden.

InformationsquelleAutor der Antwort jalf

Steuern Sie die Zugriffsrechte für die Mitglieder und Funktionen verwenden Private/Protected/Public Recht?
vorausgesetzt, die Idee der jede und jeder dieser 3 Ebenen ist klar, dann sollte es klar sein, dass wir etwas verpassen...

Die Erklärung von einem Mitglied/Funktion geschützt ist, ist zum Beispiel ziemlich allgemein. Sagen Sie, daß diese Funktion ist außerhalb der Reichweite für jeder (außer für eine geerbte Kind natürlich). Aber was ist mit Ausnahmen? jedes Sicherheits-system, können Sie haben eine Art "weiße Liste", richtig?

So Freund können, haben Sie die Flexibilität, solide Objekt in isolation, sondern erlaubt für ein "Schlupfloch" geschaffen werden, für Dinge, die Sie fühlen, sind gerechtfertigt.

Ich denke, die Leute sagen es ist nicht nötig, weil es immer ein design, das zu tun, ohne es. Ich denke, es ist ähnlich wie die Diskussion von globalen Variablen: Sie sollten nie, Es gibt immer einen Weg, das zu tun ohne Sie... aber in der Realität, Sie die Fälle sehen, wo das endet als die (fast) die meisten elegante Art und Weise... ich denke, das ist der gleiche Fall mit Freunden.

Ist es nicht eigentlich etwas gutes tun, anderes als Sie Zugriff auf eine member-variable ohne Verwendung eines setting-Funktion

nun, das ist nicht genau die Art und Weise, es zu betrachten.
Die Idee ist, zu kontrollieren, WER Zugang zu was, haben oder nicht Einstellung Funktion hat das wenig zu tun.

InformationsquelleAutor der Antwort csmba

Freund kommt praktisch, wenn Sie den Aufbau einer container und Sie möchten, implementieren Sie einen iterator für die Klasse.

InformationsquelleAutor der Antwort rptony

Dem Erfinder von C++ sagt, dass ist nicht Broker jeder encapsulation-Prinzip, und ich zitiere ihn:

Bedeutet "Freund" gegen Kapselung?
Nein. Tut es aber nicht. "Freund" ist ein expliziter Mechanismus für die Gewährung des Zugriffs, genau wie die Mitgliedschaft. Sie kann nicht (in ein standard-konformes Programm) gewähren sich Zugriff auf eine Klasse zu verändern, ohne seine Quelle.

Ist mehr als klar...

InformationsquelleAutor der Antwort

Andere Verwendung: Freund (+ virtuelle Vererbung) kann verwendet werden, um zu vermeiden, die sich aus einer Klasse (aka: "machen Sie eine Klasse underivable") => EinsZwei

Vom Zwei:

 class Fred;

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

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

InformationsquelleAutor der Antwort Gian Paolo Ghilardi

Hinblick auf operator<< und-operator>> es gibt keinen guten Grund, um diese Operatoren Freunde. Es ist wahr, dass Sie sollten nicht werden member-Funktionen, aber Sie müssen nicht Freunde sein, entweder.

Das beste, was zu tun ist, erstellen Sie öffentliche print(ostream&) und read(istream&) - Funktionen. Dann schreiben Sie den operator<< und-operator>> in Bezug auf diese Funktionen. Dies bietet den zusätzlichen Vorteil, dass Sie um jene Funktionen, die virtuellen, die eine virtuelle Serialisierung.

InformationsquelleAutor der Antwort

Müssen Sie sehr vorsichtig sein, wenn/, wo Sie mit den friend Schlüsselwort, und, wie Sie, ich habe es sehr selten. Im folgenden sind einige Hinweise zur Verwendung friend und die alternativen.

Lassen Sie uns sagen, Sie wollen den Vergleich von zwei Objekten, um zu sehen, ob Sie gleich sind. Sie können entweder:

• Verwendung von accessor-Methoden für den Vergleich (kontrollieren Sie jeden ivar und bestimmen der Geschlechter).
• Oder, könnten Sie Zugriff auf alle Mitglieder direkt öffentlich zu machen.

Das problem bei der ersten option ist, dass könnte eine MENGE Zugriffsmethoden, die (etwas) langsamer als direct variable access, schwerer zu Lesen und zu umständlich. Das problem mit dem zweiten Ansatz ist, dass Sie vollständig zu brechen Kapselung.

Schön wäre es, wenn wir definieren eine externe Funktion, die könnte immer noch Zugriff auf die privaten Elemente einer Klasse. Wir können dies tun, mit der friend Stichwort:

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

Die Methode equal(Beer, Beer) jetzt direkten Zugang zu a und b's private Mitglieder (die kann char *brandfloat percentAlcohol usw. Dies ist eine eher gekünstelt Beispiel, würden Sie früher anwenden friend auf einen überladenen == operatoraber dazu kommen wir.

Einige Dinge zu beachten:

• Eine friend ist NICHT eine member-Funktion der Klasse
• Es ist eine ganz normale Funktion mit speziellen Zugriff auf die privaten Elemente der Klasse
• Ersetzen nicht alle Zugriffsmethoden und Mutatoren mit Freunden (Sie können auch alles machen public!)
• Freundschaft nicht auf Gegenseitigkeit
• Freundschaft ist nicht transitiv
• Freundschaft ist nicht geerbt
• Oder, wie die C++ - FAQ erklärt: "Nur weil ich gewähren Sie Freundschaft, der Zugang zu mich nicht automatisch zu gewähren, die Ihre Kinder den Zugang zu mir, bedeutet das nicht automatisch gönnen Sie Ihren Freunden Zugang zu mir, und nicht automatisch gewährt mir Zugang zu Ihnen."

Ich nur wirklich nutzen friends wenn es ist viel schwieriger, es zu tun die andere Weise. Als ein weiteres Beispiel, viele Vektor-Mathematik-Funktionen werden oft erstellt, wie friends aufgrund der Interoperabilität der Mat2x2Mat3x3Mat4x4Vec2Vec3Vec4etc. Und es ist einfach so viel einfacher, Freunde zu sein, anstatt zu verwenden Accessoren überall. Wie wies darauf hin, friend ist oft nützlich, wenn angewandt, um die << (sehr nützlich zum Debuggen), >> und vielleicht die == Betreiber, kann aber auch verwendet werden, für so etwas wie dieses:

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 glaube nicht, verwenden friend sehr oft an, aber jedes jetzt und dann ist es genau das, was Sie brauchen. Hoffe, das hilft!

InformationsquelleAutor der Antwort

Tun TDD viele Male, die ich verwendet habe, 'Freund' Schlüsselwort in C++.
Kann ein Freund alles über mich wissen?

Nein, es ist nur eine eine Art Freundschaft :`(

InformationsquelleAutor der Antwort roo

Friend-Funktionen und Klassen ermöglichen den direkten Zugriff auf private und protected-Elemente der Klasse, um zu vermeiden, bricht die Kapselung im Allgemeinen Fall. Die meisten Nutzung ist mit ostream: wir möchten in der Lage sein, um Typ:

Point p;
cout << p;

Jedoch, dieser kann verlangen, Zugriff auf die privaten Daten der Punkt, so definieren wir den überladenen operator

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

Gibt es offensichtlich Kapselung Auswirkungen, jedoch. Erste, jetzt die friend-Klasse oder-Funktion hat vollen Zugriff auf ALLE member der Klasse, sogar diejenigen, die nicht beziehen sich auf deren Bedürfnisse. Zweitens, die Implementierungen von der Klasse und der Freund sind jetzt verstrickt ist, zu dem Punkt, wo eine interne Veränderung in der Klasse brechen kann und der Freund.

Wenn Sie die Freundin als eine Erweiterung der Klasse, dann ist dies nicht ein Problem, logisch gesehen. Aber, in diesem Fall, warum war es notwendig, separate aus dem Freund in den ersten Platz.

Das gleiche zu erreichen, dass die 'Freunde' behaupten zu erzielen, aber ohne zu brechen Verkapselung, 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;
    }
}; 

Kapselung ist nicht gebrochen, Klasse B hat keinen Zugriff auf die interne Implementierung in Einer, aber das Ergebnis ist das gleiche, als wenn wir erklärt hatten, dass B ein Freund von A.
Der compiler optimieren wird, entfernt die Funktion Aufrufe, so wird diese Folge in der gleichen Anweisungen, die einen direkten Zugang.

Ich denke, mit 'Freund' ist einfach eine Verknüpfung mit wohl Vorteil, aber definitiv Kosten.

InformationsquelleAutor der Antwort

Als Referenz für friend-Deklaration sagt:

Die friend-Deklaration in einem Klasse Körper und gewährt eine Funktion oder einer anderen Klasse der Zugriff auf private und protected Mitglieder der Klasse, in der die friend-Deklaration.

Also nur als Erinnerung, gibt es technische Fehler in einigen der Antworten, die sagen, dass friend kann nur besuchen geschützt Mitglieder.

InformationsquelleAutor der Antwort

Können Sie verwenden, Freundschaft, wenn unterschiedliche Klassen (nicht die Erben einer von den anderen), sind mit private oder protected-Elemente der anderen Klasse.

Typische Anwendungsfälle von Freund-Funktionen sind Operationen, die sind
die zwischen zwei verschiedenen Klassen den Zugriff auf private oder protected
die Mitglieder der beiden.

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

Können Sie sehen, dieses Beispiel, in dem nicht-member-Methode greift auf die private-Elemente einer Klasse. Diese Methode hat erklärt, in diesem sehr Klasse als friend der Klasse.

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

InformationsquelleAutor der Antwort

Dies kann nicht sein, eine tatsächliche use-case-situation, sondern kann helfen, zu veranschaulichen, die Verwendung von Freund zwischen den Klassen.

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 Mitglieder der Klasse

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

Annehmlichkeiten

class Amenity{};

Wenn man sich die Beziehungen dieser Klassen hier; das Clubhaus hält eine Vielzahl von verschiedenen Arten von Mitgliedschaften und die Mitgliedschaft Zugang. Die Mitglieder sind alle abgeleitet von einer super-oder Basisklasse, da Sie alle teilen eine ID und einen Aufzählungstyp, die Häufig sind und außerhalb von Klassen, Zugriff auf Ihren IDs und-Typen in access-Funktionen, die in der Basisklasse.

Jedoch durch diese Art der Hierarchie der Mitglieder und deren Abgeleiteten Klassen und deren Beziehung mit dem Clubhaus-Klasse die einzige, die von der abgeleiteten Klasse mit "besonderen Privilegien" ist der VIPMember-Klasse. Die Basisklasse und die anderen 2 abgeleiteten Klassen keinen Zugriff auf das Clubhaus der joinVIPEvent () - Methode, noch die VIP-Member-Klasse hat das Privileg, als ob es hat vollen Zugriff auf das Ereignis.

Also mit der VIPMember und das Clubhaus es ist ein zwei-Wege-Strasse für den Zugang, wo die andere Member-Klassen beschränkt sind.

InformationsquelleAutor der Antwort

Freunde sind auch nützlich für die Rückrufe. Sie konnte Rückrufe implementieren wie statische Methoden

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

wo callback Anrufe localCallback intern, und die clientData hat Ihre Instanz. Meiner Meinung nach,

... oder

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

Was dies ermöglicht, ist für den Freund zu sein, einen definierten, rein in die cpp als c-style-Funktion, und nicht Krempel in die Klasse.

Ebenso ein Muster, die ich gesehen habe sehr oft ist, um alle wirklich private Mitglieder einer Klasse in eine andere Klasse, die ist deklariert in der header-Definition in der cpp-und friended. Dies ermöglicht es dem Programmierer zu verbergen einiges der Komplexität und internen arbeiten der Klasse von dem Benutzer des headers.

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

Wird es einfacher, Dinge zu verbergen, dass der nachgeschaltete muss nicht sehen diese Weise.

InformationsquelleAutor der Antwort shash