Überladen von Operatoren: Member-Funktion vs. Nicht-Member-Funktion?

Ich habe gelesen, dass ein überladener Operator als Member-Funktion deklariert ist asymmetrisch weil es nur einen Parameter haben kann und der andere Parameter automatisch übergeben wird this Zeiger. Es gibt also keinen Standard, um sie zu vergleichen. Andererseits wird der überladene Operator als a deklariert friend ist symmetrisch weil wir zwei Argumente des gleichen Typs übergeben und sie daher verglichen werden können.

Meine Frage ist, warum Freunde bevorzugt werden, wenn ich immer noch den lvalue eines Zeigers mit einer Referenz vergleichen kann? (Die Verwendung einer asymmetrischen Version ergibt die gleichen Ergebnisse wie eine symmetrische) Warum verwenden STL-Algorithmen nur symmetrische Versionen?

Wenn Sie Ihre mit dem Operator überladene Funktion als Member-Funktion definieren, übersetzt der Compiler Ausdrücke wie s1 + s2 hinein s1.operator+(s2). Das heißt, die mit dem Operator überladene Elementfunktion wird für den ersten Operanden aufgerufen. So funktionieren Mitgliederfunktionen!

Was aber, wenn der erste Operand keine Klasse ist? Es gibt ein großes Problem, wenn wir einen Operator überladen wollen, bei dem der erste Operand kein Klassentyp ist, sondern sagen wir double. So kann man also nicht schreiben 10.0 + s2. Sie können jedoch eine mit Operatoren überladene Elementfunktion für Ausdrücke wie schreiben s1 + 10.0.

Um dies zu lösen Bestellung Problem, wir definieren eine operatorüberladene Funktion als friend WENN es zugreifen muss private Mitglieder. Mach es friend NUR wenn auf private Mitglieder zugegriffen werden muss. Ansonsten einfach machen Nicht-Freund Nicht-Mitglied Funktion zu verbessern Verkapselung!

class Sample
{
 public:
    Sample operator + (const Sample& op2); //works with s1 + s2
    Sample operator + (double op2); //works with s1 + 10.0

   //Make it `friend` only when it needs to access private members. 
   //Otherwise simply make it **non-friend non-member** function.
    friend Sample operator + (double op1, const Sample& op2); //works with 10.0 + s2
}

Lese das :
Ein kleines Problem beim Sortieren von Operanden
Wie Nicht-Member-Funktionen die Kapselung verbessern

Es ist nicht unbedingt eine Unterscheidung zwischen friend Operatorüberladungen und Elementfunktionsoperatorüberladungen, wie sie zwischen liegen global Operatorüberladungen und Memberfunktionsoperatorüberladungen.

Ein Grund, a global Die Operatorüberladung ist, wenn Sie Ausdrücke zulassen möchten, in denen der Klassentyp in der angezeigt wird rechts Handseite eines binären Operators. Zum Beispiel:

Foo f = 100;
int x = 10;
cout << x + f;

Dies funktioniert nur, wenn eine globale Operatorüberladung für vorhanden ist

Foo-Operator + (int x, const Foo& f);

Beachten Sie, dass die Überladung des globalen Operators nicht unbedingt a sein muss friend Funktion. Dies ist nur erforderlich, wenn Zugriff auf private Mitglieder benötigt wird Fooaber das ist nicht immer der Fall.

Egal, ob Foo hatte nur eine Memberfunktionsoperatorüberladung, wie:

class Foo
{
  ...
  Foo operator + (int x);
  ...
};

… dann könnten wir nur Ausdrücke haben, bei denen a Foo Instanz erscheint auf der links des Plusoperators.