Member access operators

Accède à un membre de son opérande.

Explication

L'opérateur subscript intégré fournit l'accès à un objet pointé par l'opérande pointeur ou tableau .

L'opérateur d' indirection intégré fournit l'accès à un objet ou une fonction pointé(e) par l'opérande pointeur.

L'opérateur intégré address-of crée un pointeur pointant vers l'objet ou la fonction opérande.

Membre d'objet et pointeur vers membre d'objet - ces opérateurs permettent d'accéder à un membre de données ou à une fonction membre de l'opérande objet.

Les opérateurs intégrés member of pointer et pointer to member of pointer permettent d'accéder à un membre de données ou à une fonction membre de la classe pointée par l'opérande pointeur.

Opérateur d'indice intégré

Les expressions d'opérateur d'indice ont la forme

L'expression d'indice intégrée E1 [ E2 ] est exactement identique à l'expression * ( E1 + E2 ) sauf pour sa catégorie de valeur (voir ci-dessous) et l' ordre d'évaluation (depuis C++17) : l'opérande pointeur (qui peut résulter d'une conversion tableau-vers-pointeur, et qui doit pointer vers un élément d'un tableau ou un élément au-delà de la fin) est ajusté pour pointer vers un autre élément du même tableau, suivant les règles de l' arithmétique des pointeurs , puis est déréférencé.

Lorsqu'il est appliqué à un tableau, l'expression d'indice est une lvalue si le tableau est une lvalue, et une xvalue s'il ne l'est pas (depuis C++11) .

Lorsqu'il est appliqué à un pointeur, l'expression en indice est toujours une lvalue.

Le type T ne doit pas être un type incomplet , même si la taille ou la structure interne de T n'est jamais utilisée, comme dans & x [ 0 ] .

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , pour chaque type d'objet T (éventuellement qualifié cv), la signature de fonction suivante participe à la résolution de surcharge :

#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"; // utilise la version [{...}]
}

4242

Opérateur d'indirection intégré

Les expressions d'opérateur d'indirection ont la forme

L'opérande de l'opérateur de déréférencement intégré doit être un pointeur vers un objet ou un pointeur vers une fonction, et le résultat est la lvalue référençant l'objet ou la fonction vers lequel expr pointe. Si expr ne pointe pas réellement vers un objet ou une fonction, le comportement est indéfini (sauf dans le cas spécifié par typeid ).

Un pointeur vers (éventuellement cv -qualifié) void ne peut pas être déréférencé. Les pointeurs vers d'autres types incomplets peuvent être déréférencés, mais la lvalue résultante ne peut être utilisée que dans des contextes qui autorisent une lvalue de type incomplet, par exemple lors de l'initialisation d'une référence.

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , pour chaque type T qui est soit un type objet (éventuellement qualifié cv) soit un type fonction (non qualifié const ou ref), la signature de fonction suivante participe à la résolution de surcharge :

#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
    int& r = *pn; // une lvalue peut être liée à une référence
    int m = *pn;  // indirection + conversion lvalue-vers-rvalue
    int (*fp)() = &f;
    int (&fr)() = *fp; // une lvalue de fonction peut être liée à une référence
    [](...){}(r, m, fr); // supprime les éventuels avertissements "variable inutilisée"
}

Opérateur d'adresse intégré

Les expressions d'opérateur d'adresse ont la forme

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , cet opérateur n'introduit aucune signature de fonction supplémentaire : l'opérateur d'adresse intégré ne s'applique pas s'il existe une surcharge de operator & qui est une fonction viable .

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &n;    // pointeur
    int* pn2 = &*pn; // pn2 == pn
    int A::* mp = &A::i;      // pointeur vers membre de données
    void (B::*mpf)() = &B::f; // pointeur vers fonction membre
    void (*pf)(int) = &f; // résolution de surcharge due au contexte d'initialisation
//  auto pf2 = &f; // erreur : type de fonction surchargée ambigu
    auto pf2 = static_cast<void (*)(int)>(&f); // résolution de surcharge due au cast
}

Opérateurs d'accès aux membres intégrés

Les expressions d'opérateur d'accès membre ont la forme

id-expr est un nom (formellement, une expression d'identifiant qui désigne) un membre de données ou une fonction membre de T ou d'une classe de base B non ambiguë et accessible de T (par ex. E1. E2 ou E1 - > E2 ), optionnellement qualifié (par ex. E1. B :: E2 ou E1 - > B :: E2 ), optionnellement en utilisant le template disambiguateur (par ex. E1. template E2 ou E1 - > template E2 ).

Si un operator - > défini par l'utilisateur est appelé, operator - > est appelé à nouveau sur la valeur résultante, récursivement, jusqu'à ce qu'un operator - > soit atteint qui renvoie un pointeur brut. Après cela, la sémantique intégrée est appliquée à ce pointeur.

L'expression E1 - > E2 est exactement équivalente à ( * E1 ) . E2 pour les types natifs ; c'est pourquoi les règles suivantes ne concernent que E1. E2 .

Dans l'expression E1. E2 :

operator. ne peut pas être surchargé, et pour operator - > , dans la résolution de surcharge face aux opérateurs définis par l'utilisateur , l'opérateur intégré n'introduit aucune signature de fonction supplémentaire : l'opérateur intégré operator - > ne s'applique pas s'il existe un operator - > surchargé qui est une fonction viable .

#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;
        // mot-clé template nécessaire pour un membre template dépendant
        int* p = T().template ptr<U>();
        p->~U(); // U est int, appelle le pseudo-destructeur de int
        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 fonctionne également
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf() fonctionne également
//            << &a.f << ' '   // erreur : mal formé si a.f n'est pas le
                               // opérande gauche de operator()
//            << a.B << ' '    // erreur : type imbriqué non autorisé
              << a.RED << ' '; // énumérateur
    UPtrWrapper uPtrWrap{std::make_unique<std::string>("wrapped")};
    assert(uPtrWrap->data() == uPtrWrap.operator->().operator->()->data());
}

1 2 11 4 1

Si E2 est un membre non statique et que le résultat de E1 est un objet dont le type n'est pas similaire au type de E1 , le comportement est indéfini :

struct A { int i; };
struct B { int j; };
struct D : A, B {};
void f()
{
    D d;
    static_cast<B&>(d).j;      // OK, l'expression d'objet désigne le sous-objet B de d
    reinterpret_cast<B&>(d).j; // comportement indéfini
}

Opérateurs d'accès aux pointeurs vers membres intégrés

Les expressions d'opérateur d'accès aux membres via des pointeurs vers des membres ont la forme

rhs doit être une rvalue de type pointeur vers membre ( data ou function ) de T ou pointeur vers membre d'une classe de base B de T non ambiguë et accessible.

L'expression E1 - > * E2 est exactement équivalente à ( * E1 ) . * E2 pour les types natifs ; c'est pourquoi les règles suivantes ne concernent que E1. * E2 .

Dans l'expression E1. * E2 :

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , pour chaque combinaison de types D , B , R , où le type de classe B est soit la même classe que D , soit une classe de base non ambiguë et accessible de D , et R est soit un type objet soit un type fonction, la signature de fonction suivante participe à la résolution de surcharge :

où les deux opérandes peuvent être qualifiés cv, auquel cas la qualification cv du type de retour est l'union des qualifications cv des opérandes.

#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; // erreur : impossible de modifier via mutable
    std::cout << s.*pmi << '\n';
    D d(7); // les pointeurs de base fonctionnent avec l'objet dérivé
    D* pd = &d;
    std::cout << (d.*pf)(7) << ' '
              << (pd->*pf)(8) << '\n';
}

7
14 15

Bibliothèque standard

L'opérateur d'indice est surchargé par de nombreuses classes de conteneurs standards :

Les opérateurs d'indirection et de membre sont surchargés par de nombreux itérateurs et classes de pointeurs intelligents :

Aucune classe de la bibliothèque standard ne surcharge operator & . L'exemple le plus connu de operator & surchargé est la classe Microsoft COM CComPtr , bien qu'il puisse également apparaître dans des EDSL tels que boost.spirit .

Aucune classe de la bibliothèque standard ne surcharge operator - > * . Il a été suggéré que cela pourrait faire partie de l'interface des pointeurs intelligents , et en effet il est utilisé dans cette capacité par les acteurs dans boost.phoenix , mais est plus courant dans les EDSL tels que cpp.react .

Notes

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

Priorité des opérateurs

Surcharge d'opérateur