différence entre « :: » et « -> »

Question

En C++ est-il une différence entre ces 3 blocs de code:

MyClass->m_Integer // 1 
MyClass::m_Integer // 2 
MyClass.m_Integer // 3 

Answer 1

Le -> et . opérateurs moyen d'accéder à des membres de une instance d'une classe, et :: vous permet d'accéder aux membres statiques d'une classe.

La différence entre -> et . est que la flèche est pour l'accès via des pointeurs vers des instances, où le point est pour l'accès aux valeurs (non-pointeurs).

Par exemple, disons que vous avez une classe MyClass définie comme:

class MyClass 
{ 
public: 
    static int someValue(); 
    int someOtherValue(); 
}; 

Vous utilisez ces opérateurs dans les situations suivantes:

MyClass *ptr = new MyClass; 
MyClass value; 

int arrowValue = ptr->someOtherValue(); 
int dotValue = value.someOtherValue(); 
int doubleColonValue = MyClass::someValue(); 

En Java, cela ressemblerait à ceci:

MyClass ref = new MyClass; 

int dotValue = ref.someOtherValue(); 
int doubleColonValue = MyClass.someValue(); 

Answer 2

-> signifie que MyClass est un pointeur vers la classe et que le pointeur doit être deref erenced pour accéder au membre m_Integer

:: est l'opérateur d'étendue ou d'espace de nom. Cela signifie que m_Integer est soit statique, soit vous devez identifier spécifiquement la portée ou l'espace de noms dans lequel m_Integer se trouve.

. signifie que m_Integer est en train d'accéder directement (pas via un pointeur) depuis MyClass. C'est à peu près la façon dont vous accèderiez aux membres depuis Java et devrait être celle que vous connaissez le mieux.

Answer 3

• a::b - a est un espace de noms ou d'une classe (pas une instance), et par conséquent b doit être une entité statique
• a.b-a est une instance d'une classe et b est son membre
• a->b - comme (*a).b (a est un pointeur vers une instance d'une classe)

Answer 4

le long de l'autre réponses que vous avez obtenu, il est à noter que operator-> peut être surchargé. Vous avez déjà obtenu des explications raisonnables sur le fonctionnement de la version intégrée, mais un operator-> surchargé est quelque peu inhabituel, alors peut-être que cela vaut la peine d'ajouter un peu à son fonctionnement.

La norme décrit comment operator-> est inhabituel de façon assez succincte (§13.5.6):

Une expression X-> m est interprété comme (x.operator ->()) -> m pour une classe l'objet x de type T si T :: operator ->() existe et si l'opérateur est sélectionné comme meilleure fonction de correspondance par le mécanisme de résolution de surcharge (13.3).

Cela a deux conséquences:

1. Même si -> ressemble à un opérateur binaire, d'un point de vue de la surcharge, il est essentiellement un opérateur unaire - votre surcharge sera fonction de membre qui prend pas d'argument.
2. Votre surcharge doit renvoyer un de deux types: soit une (référence à) une instance d'une autre classe qui surcharge également operator->, ou bien un pointeur vers un objet (de classe ou de type struct).

Comme vous pouvez retourner un objet qui se Surcharges operator->, une expression de la forme x->m peut cacher une quantité arbitraire de la complexité (un nombre arbitraire de fonctions appelé). Ce que vous écrivez x->m pourrait vraiment s'étendre à x->y->z->a->b->...m.