Y a-t-il une différence générale entre faire
(*ptr).method()
contre
ptr->method()
J'ai vu cette question dans un commentaire sur une autre question et j'ai pensé la poser ici. Bien que je me souvienne juste que presque tous les opérateurs en C++ peuvent être surchargés, donc je suppose que la réponse dépendra. Mais en général, y a-t-il une différence entre faire l'un contre l'autre?
Comme "jamesdlin" l'a déjà noté, les opérateurs *
Et ->
Peuvent être surchargés pour les types de classe.
Et puis les deux expressions (*ptr).method()
Et ptr->method()
peuvent avoir un effet différent.
Cependant, pour les opérateurs intégrés les deux expressions sont équivalentes.
L'opérateur ->
Est plus pratique lorsque vous suivez une chaîne de pointeurs, car .
A une priorité plus élevée que *
, Ce qui nécessite donc beaucoup de parenthèses incassables.
Considérer:
pBook->author->snailMail->Zip
versus
(*(*(*pBook).author).snailMail).Zip
Pour les types de pointeurs bruts, ils sont équivalents.
Et oui, pour les types généraux, la réponse est en effet "cela dépend", car les classes peuvent surcharger operator*
et operator->
d'avoir des comportements différents.
Oui. ptr->method()
est deux caractères plus court que (*ptr).method()
.
C'est aussi plus joli.
Norme C++ 5.2.5/3:
Si E1 a le type "pointeur vers la classe X", alors l'expression E1-> E2 est convertie sous la forme équivalente (* (E1)). E2;
Pour les valeurs sans pointeur, les opérateurs peuvent être surchargés.
Mais en général, y a-t-il une différence entre faire l'un contre l'autre?
Non! (sauf si ->
et *
sont explicitement surchargés pour exécuter différentes fonctions)
ptr->method()
et (*ptr).method()
sont équivalents.
Désolé de creuser ce post, mais même si les expressions dans l'OP sont équivalentes pour les types de pointeurs bruts, je pense qu'il y a au moins une différence importante à mentionner en C++, en plus de tout ce qui a été dit:
À partir de Wikipedia ( http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#cite_note-arrowptr-6 ):
Le type de retour de l'opérateur -> () doit être un type pour lequel l'opération -> peut être appliquée, comme un type de pointeur. Si x est de type C où C surcharge l'opérateur -> (), x-> y est développé en x.operator -> () -> y.
Ceci implique que ->
devrait renvoyer un type déréférençable , tandis que *
devrait renvoyer un type déréférencé , et donc ce "chaînage" s'applique à ->
seulement.
Le ->
la séquence sert d'indicateur visuel qu'elle pointe vers quelque chose. Les deux opérateurs effectuent exactement la même séquence d'opérations.
Ce sont des synonymes. Ce dernier est un raccourci pour le premier.