Que puis-je utiliser à la place de l'opérateur flèche, `->`?

À quoi sert l'opérateur flèche ( ->)?

Les deux expressions suivantes sont équivalentes:

a->b

(*a).b

(sujet à une surcharge de l'opérateur, comme le mentionne Konrad, mais c'est inhabituel).

a->best généralement synonyme de (*a).b. Les parenthèses ici sont nécessaires en raison de la force de liaison des opérateurs *et .: *a.bne fonctionnerait pas car la liaison .est plus forte et est exécutée en premier. C'est donc équivalent à *(a.b).

Méfiez-vous de la surcharge, cependant: comme les deux ->et *peuvent être surchargés, leur signification peut différer radicalement.

Le langage C ++ définit l'opérateur de flèche ( ->) comme synonyme de déréférencement d'un pointeur, puis utilise l' .opérateur sur cette adresse.

Par exemple:

Si vous avez un objet, anObjectet un pointeur, aPointer:

SomeClass anObject = new SomeClass();
SomeClass *aPointer = &anObject;

Pour pouvoir utiliser l'une des méthodes d'objets, vous déréférencez le pointeur et effectuez un appel de méthode sur cette adresse:

(*aPointer).method();

Ce qui pourrait être écrit avec l'opérateur flèche:

aPointer->method();

La principale raison de l'existence de l'opérateur de flèche est qu'il raccourcit la saisie d'une tâche très courante et qu'il est également assez facile d'oublier les parenthèses autour du déréférencement du pointeur. Si vous avez oublié les parenthèses, l'opérateur.-Se liera plus fort que * -operator et fera exécuter notre exemple comme:

*(aPointer.method()); // Not our intention!

Certaines des autres réponses ont également mentionné à la fois que les opérateurs C ++ peuvent être surchargés et que ce n'est pas si courant.

En C ++ 0x, l'opérateur obtient une seconde signification, indiquant le type de retour d'une fonction ou d'une expression lambda

auto f() -> int; // "->" means "returns ..."

Je le lis principalement de droite à gauche et j'appelle "in"

foo->bar->baz = qux->croak

devient:

"baz in bar in foo devient croak in qux."

-> est utilisé lors de l'accès aux données sur lesquelles vous avez un pointeur.

Par exemple, vous pouvez créer un pointeur ptr vers une variable de type int intVar comme ceci:

int* prt = &intVar;

Vous pouvez alors utiliser une fonction, telle que foo, uniquement en déréférençant ce pointeur - pour appeler la fonction sur la variable vers laquelle pointe le pointeur, plutôt que sur la valeur numérique de l'emplacement mémoire de cette variable:

(*ptr).foo();

Sans les parenthèses ici, le compilateur comprendrait cela comme *(ptr.foo())dû à la priorité des opérateurs qui n'est pas ce que nous voulons.

C'est en fait la même chose que de taper

ptr->foo();

Comme les ->déréférences ce pointeur, et ainsi appelle la fonction foo()sur la variable vers laquelle le pointeur pointe pour nous.

De même, nous pouvons utiliser ->pour accéder ou définir un membre d'une classe:

myClass* ptr = &myClassMember;
ptr->myClassVar = 2; 

Vous pouvez utiliser -> pour définir une fonction.

auto fun() -> int
{
return 100;
}

Ce n'est pas un lambda. C'est vraiment une fonction. "->" indique le type de retour de la fonction.