Member access operators

Greift auf ein Mitglied seines Operanden zu.

Erklärung

Der eingebaute Subscript-Operator ermöglicht den Zugriff auf ein Objekt, auf das der Pointer - oder Array -Operand zeigt.

Der eingebaute Indirektionsoperator ermöglicht den Zugriff auf ein Objekt oder eine Funktion, auf die der Zeigeroperand zeigt.

Der eingebaute address-of Operator erzeugt einen Zeiger, der auf das Objekt oder die Funktion des Operanden zeigt.

Member of object und pointer to member of object Operatoren ermöglichen den Zugriff auf ein Datenelement oder eine Memberfunktion des Objektoperanden.

Eingebaute Zeiger-auf-Mitglied und Zeiger-auf-Mitglied-eines-Zeigers Operatoren ermöglichen den Zugriff auf ein Datenelement oder eine Memberfunktion der Klasse, auf die der Zeigeroperand zeigt.

Eingebauter Subskript-Operator

Die Indexoperatorausdrücke haben die Form

Der eingebaute Indexausdruck E1 [ E2 ] ist exakt identisch mit dem Ausdruck * ( E1 + E2 ) abgesehen von seiner Wertkategorie (siehe unten) und der Auswertungsreihenfolge (seit C++17) : Der Zeigeroperand (der das Ergebnis einer Array-zu-Zeiger-Konvertierung sein kann und auf ein Element eines Arrays oder auf das Element nach dem Ende zeigen muss) wird angepasst, um auf ein anderes Element desselben Arrays zu zeigen, gemäß den Regeln der Zeigerarithmetik , und wird dann dereferenziert.

Wenn auf ein Array angewendet, ist der Indexausdruck ein lvalue wenn das Array ein lvalue ist, und ein xvalue wenn es keiner ist (since C++11) .

Wenn auf einen Zeiger angewendet, ist der Subskriptausdruck immer ein Lvalue.

Der Typ T darf kein unvollständiger Typ sein, selbst wenn die Größe oder interne Struktur von T niemals verwendet wird, wie in & x [ 0 ] .

Bei Überladungsauflösung für benutzerdefinierte Operatoren nimmt für jeden Objekttyp T (möglicherweise cv-qualifiziert) die folgende Funktionssignatur an der Überladungsauflösung teil:

#include <iostream>
#include <map>
#include <string>
int main()
{
    int a[4] = {1, 2, 3, 4};
    int* p = &a[2];
    std::cout << p[1] << p[-1] << 1[p] << (-1)[p] << '\n';
    std::map<std::pair<int, int>, std::string> m;
    m[{1, 2}] = "abc"; // verwendet die [{...}] Version
}

4242

Eingebauter Indirektionsoperator

Die Dereferenzierungsoperator-Ausdrücke haben die Form

Der Operand des eingebauten Dereferenzierungsoperators muss ein Zeiger auf ein Objekt oder ein Zeiger auf eine Funktion sein, und das Ergebnis ist der Lvalue, der sich auf das Objekt oder die Funktion bezieht, auf die expr zeigt. Wenn expr nicht tatsächlich auf ein Objekt oder eine Funktion zeigt, ist das Verhalten undefiniert (mit Ausnahme des durch typeid spezifizierten Falls).

Ein Zeiger auf (möglicherweise cv -qualifizierten) void kann nicht dereferenziert werden. Zeiger auf andere unvollständige Typen können dereferenziert werden, aber der resultierende L-Wert kann nur in Kontexten verwendet werden, die einen L-Wert eines unvollständigen Typs erlauben, z.B. bei der Initialisierung einer Referenz.

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nimmt für jeden Typ T , der entweder ein Objekttyp (möglicherweise cv-qualifiziert) oder ein Funktionstyp (nicht const- oder ref-qualifiziert) ist, die folgende Funktionssignatur an der Überlagerungsauflösung teil:

#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
    int& r = *pn; // Lvalue kann an eine Referenz gebunden werden
    int m = *pn;  // Indirektion + Lvalue-zu-Rvalue-Konvertierung
    int (*fp)() = &f;
    int (&fr)() = *fp; // Funktions-Lvalue kann an eine Referenz gebunden werden
    [](...){}(r, m, fr); // entfernt mögliche "unbenutzte Variable"-Warnungen
}

Eingebauter Adressoperator

Die Adressoperator-Ausdrücke haben die Form

Bei Überlagerungsauflösung gegenüber benutzerdefinierten Operatoren führt dieser Operator keine zusätzlichen Funktionssignaturen ein: Der eingebaute Adressoperator kommt nicht zur Anwendung, falls eine überladene operator & existiert, die eine geeignete Funktion darstellt.

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &n;    // Zeiger
    int* pn2 = &*pn; // pn2 == pn
    int A::* mp = &A::i;      // Zeiger auf Datenelement
    void (B::*mpf)() = &B::f; // Zeiger auf Memberfunktion
    void (*pf)(int) = &f; // Überladungsauflösung durch Initialisierungskontext
//  auto pf2 = &f; // Fehler: mehrdeutiger überladener Funktionstyp
    auto pf2 = static_cast<void (*)(int)>(&f); // Überladungsauflösung durch Cast
}

Eingebaute Member-Zugriffsoperatoren

Die Memberzugriffsoperatorausdrücke haben die Form

id-expr ist ein Name (formal ein Identifikatorausdruck , der benennt) eines Datenelements oder einer Memberfunktion von T oder einer eindeutigen und zugänglichen Basisklasse B von T (z.B. E1. E2 oder E1 - > E2 ), optional qualifiziert (z.B. E1. B :: E2 oder E1 - > B :: E2 ), optional unter Verwendung des template Disambiguators (z.B. E1. template E2 oder E1 - > template E2 ).

Wenn ein benutzerdefinierter operator - > aufgerufen wird, wird operator - > rekursiv erneut auf den resultierenden Wert angewendet, bis ein operator - > erreicht wird, der einen einfachen Zeiger zurückgibt. Danach werden die integrierten Semantiken auf diesen Zeiger angewendet.

Der Ausdruck E1 - > E2 ist exakt äquivalent zu ( * E1 ) . E2 für eingebaute Typen; deshalb behandeln die folgenden Regeln nur E1. E2 .

Im Ausdruck E1. E2 :

operator. kann nicht überladen werden, und für operator - > führt bei der Überlagerungsauflösung gegenüber benutzerdefinierten Operatoren der eingebaute Operator keine zusätzlichen Funktionssignaturen ein: Der eingebaute operator - > kommt nicht zur Anwendung, wenn eine überladene operator - > existiert, die eine geeignete Funktion ist.

#include <cassert>
#include <iostream>
#include <memory>
struct P
{
    template<typename T>
    static T* ptr() { return new T; }
};
template<typename T>
struct A
{
    A(int n): n(n) {}
    int n;
    static int sn;
    int f() { return 10 + n; }
    static int sf() { return 4; }
    class B {};
    enum E {RED = 1, BLUE = 2};
    void g()
    {
        typedef int U;
        // keyword template needed for a dependent template member
        int* p = T().template ptr<U>();
        p->~U(); // U is int, calls int's pseudo destructor
        delete p;
    }
};
template<>
int A<P>::sn = 2;
struct UPtrWrapper
{
    std::unique_ptr<std::string> uPtr;
    std::unique_ptr<std::string>& operator->() { return uPtr; }
};
int main()
{
    A<P> a(1);
    std::cout << a.n << ' '
              << a.sn << ' '   // A::sn also works
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf() also works
//            << &a.f << ' '   // error: ill-formed if a.f is not the
                               // left-hand operand of operator()
//            << a.B << ' '    // error: nested type not allowed
              << a.RED << ' '; // enumerator
    UPtrWrapper uPtrWrap{std::make_unique<std::string>("wrapped")};
    assert(uPtrWrap->data() == uPtrWrap.operator->().operator->()->data());
}

1 2 11 4 1

Wenn E2 ein nicht-statisches Mitglied ist und das Ergebnis von E1 ein Objekt ist, dessen Typ nicht ähnlich zum Typ von E1 ist, ist das Verhalten undefiniert:

struct A { int i; };
struct B { int j; };
struct D : A, B {};
void f()
{
    D d;
    static_cast<B&>(d).j;      // OK, Objektausdruck bezeichnet das B-Subobjekt von d
    reinterpret_cast<B&>(d).j; // undefiniertes Verhalten
}

Eingebaute Zeiger-auf-Member-Zugriffsoperatoren

Die Ausdrücke für den Elementzugriffsoperator über Zeiger auf Elemente haben die Form

rhs muss ein Rvalue vom Typ Zeiger auf Element ( Daten oder Funktion ) von T oder Zeiger auf Element einer eindeutigen und zugänglichen Basisklasse B von T sein.

Der Ausdruck E1 - > * E2 ist exakt äquivalent zu ( * E1 ) . * E2 für eingebaute Typen; deshalb behandeln die folgenden Regeln nur E1. * E2 .

Im Ausdruck E1. * E2 :

Bei Überlagerungsauflösung gegenüber benutzerdefinierten Operatoren nimmt für jede Kombination von Typen D , B , R , wobei der Klassentyp B entweder dieselbe Klasse wie D oder eine eindeutige und zugängliche Basisklasse von D ist, und R entweder ein Objekt- oder Funktionstyp ist, die folgende Funktionssignatur an der Überlagerungsauflösung teil:

wobei beide Operanden cv-qualifiziert sein können, in welchem Fall die cv-Qualifikation des Rückgabetyps die Vereinigung der cv-Qualifikation der Operanden ist.

#include <iostream>
struct S
{
    S(int n) : mi(n) {}
    mutable int mi;
    int f(int n) { return mi + n; }
};
struct D : public S
{
    D(int n) : S(n) {}
};
int main()
{
    int S::* pmi = &S::mi;
    int (S::* pf)(int) = &S::f;
    const S s(7);
//  s.*pmi = 10; // error: cannot modify through mutable
    std::cout << s.*pmi << '\n';
    D d(7); // base pointers work with derived object
    D* pd = &d;
    std::cout << (d.*pf)(7) << ' '
              << (pd->*pf)(8) << '\n';
}

7
14 15

Standardbibliothek

Der Subscript-Operator wird von vielen Standard-Containerklassen überladen:

Der Indirektions- und Mitgliedsoperator wird von vielen Iteratoren und Smart-Pointer-Klassen überladen:

Keine Klassen der Standardbibliothek überladen operator & . Das bekannteste Beispiel für überladenen operator & ist die Microsoft COM-Klasse CComPtr , obwohl er auch in EDSLs wie boost.spirit vorkommen kann.

Keine Standardbibliotheksklassen überladen operator - > * . Es wurde vorgeschlagen, dass es Teil der Smart-Pointer-Schnittstelle sein könnte, und tatsächlich wird es in dieser Funktion von Aktoren in boost.phoenix verwendet, ist jedoch häufiger in EDSLs wie cpp.react zu finden.

Hinweise

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

Operator-Präzedenz

Operatorüberladung