Wie funktioniert der Dereferenzierungsoperator (*), wenn er als Memberfunktion einer Klasse überladen wird?

Question

Wenn ich Bücher und Stapelüberlauf Artikel auf operator overloading nachgeschlagen, fand ich folgende:

Wenn ein überlasteter Bediener eine Elementfunktion ist, wird dies den Operanden linken gebunden. Mitgliederoperatorfunktionen haben einen (expliziten) Parameter weniger als die Anzahl der Operanden.

(Addison Wesley, C++ Primer)

So ist meine Frage, da der * (Dereferenzierung) Operator jeden linken Operanden nicht hat, wie es seine Parameter bekommt (das ist das Objekt selbst oder this)

Answer 1

Für alle Präfix-Unary-Operatoren wird der nachfolgende Operand verwendet.

Als zusätzliche Frage würde es ein Unterschied in sein, wie der überladenen * Operator verwendet wird, wenn er als Nicht-Mitglied-Funktion gegen eine Elementfunktion

Für den größten Teil definiert ist, nein, mit der Ausnahme, dass Nichtmitgliedsfunktion nicht auf privates Mitglied dieser Klasse zugreifen kann und wenn sowohl die Elementfunktion als auch die Nichtmitgliedsfunktion vorhanden ist, muss der Compiler overload resolution verwenden, um die Funktion mit höherem Rang auszuwählen. Wenn es keine bessere Funktion gibt, ist es ambivalent Anruf, siehe ADL

Für die zuverlässige Quelle, y ou kann einen Blick auf operator overloading nehmen, oder, besser, Abschnitt 13.5.1 [over.unary] in dem Standard-C++:

Ein Präfix unärer Operator wird von einer nicht-statischen Elementfunktion implementiert wird (9.3) mit keine Parameter oder eine Nichtmitgliedsfunktion mit einem Parameter. Daher kann @x für jedes Präfix für den unären Operator @ als entweder als x.operator @() oder als Operator @ (x) interpretiert werden. Wurden beide Formen der Operatorfunktion deklariert, bestimmen die Regeln in 13.3.1.2, ob eine Interpretation verwendet wird. Eine Erläuterung des Postfix unäre Operatoren ++ und - finden Sie unter 13.5.7. 2 Es wird davon ausgegangen, dass die unären und binären Formen desselben Operators denselben Namen haben. [Hinweis: ein unärer Operator kann daher einen binären Operator aus einem umschließenden Bereich ausblenden und umgekehrt. -Ende note]

Für die Auswahl, wenn es sowohl Mitglied und Nicht-Mitglied ist, siehe 13.3.1.2 [over.match.oper]

Answer 2

Präfix * arbeitet mit dem folgenden Operanden.

Für einen Benutzer definiert operator* ausgedrückt als eine Member-Funktion, das ist das Objekt, das von einem this-Ausdruck bezeichnet wird.

#include <iostream> 
using namespace std; 

struct S 
{ 
    auto operator*() const -> char const* { return "Hi there!"; } 
}; 

auto main() 
    -> int 
{ cout << *S() << endl; } 

Ergebnis:

 
Hi there! 

Answer 3

Der Dereferenzierungsoperator funktioniert genauso wie ein überladener Operator, da es wie ein gewöhnlicher Bediener tut.

int foo(int *p) 
{ 
    return *p; 
} 

In der Erklärung return *p; gilt der Dereferenzierungsoperator auf den Zeiger p. Es wird ihm auf der rechten Seite übergeben:

Als überlasteten Operator funktioniert es auf die gleiche Weise.

class bar { 

    int *some_internal_ptr; 

public: 
    int operator*() const { 
      return *some_internal_ptr; 
    } 

    // Other class members and methods... 
}; 

int foo(bar p) 
{ 
    return *p; 
} 

Wenn die rechte Seite der * Operatorklasse mit einem Operator * `Mitglied ist, es wird als eine überladene Methode der Klasse aufgerufen, nicht anders als jedes andere Mitglied, um das dereferenzieren zu lösen .

Es ist, weil die Verwendung identisch ist, warum viele C++ - Bibliotheksalgorithmen mit Zeigern oder C++ - Bibliotheksoperatoren gleich gut funktionieren. Zum Beispiel std::copy()konnte wie folgt implementiert werden (ich Trimmen einige irrelevant Komplexität weg, die nicht hier ist Germane):

template<typename iter_type> 
iter_type copy(iter_type b, iter_type e, iter_type t) 
{ 
    while (b != e) 
    { 
     *t=*b; 
     ++t; 
     ++b; 
    } 
    return t; 
} 

Sie nativen Zeiger auf std::copy passieren können, oder Klassen wie Iteratoren passieren, mit überlastet * Operatoren, und weil ein überladener Operator * mit der gleichen Syntax wie ein gewöhnlicher Operator * verwendet wird, funktioniert derselbe Algorithmus auch mit dem überladenen Operator.