Quelle est la différence entre l'opérateur point (.) Et -> en C ++?
Quelle est la différence entre l'opérateur point (.) Et -> en C++?
foo->bar() est identique à (*foo).bar().
Les parenthèses ci-dessus sont nécessaires en raison de la force de liaison des opérateurs * et ..
*foo.bar() ne fonctionnerait pas car l'opérateur Dot (.) est évalué en premier (voir priorité des opérateurs )
L'opérateur point (.) ne peut pas être surchargé, l'opérateur flèche (->) peut être surchargé.
L'opérateur Point (.) ne peut pas être appliqué aux pointeurs.
Voir aussi: Quel est l'opérateur de flèche (->) synonyme de C++?
Pour un pointeur, nous pourrions simplement utiliser
*pointervariable.foo
Mais l'opérateur . a une priorité supérieure à l'opérateur *, de sorte que . est évalué en premier. Nous devons donc forcer ceci avec des parenthèses:
(*pointervariable).foo
Mais il est difficile de taper tout le temps (), donc ils ont développé -> comme un raccourci pour dire la même chose. Si vous accédez à une propriété d'un objet ou à une référence d'objet, utilisez . Si vous accédez à une propriété d'un objet via un pointeur, utilisez ->
L'opérateur de point ne peut pas être surchargé, l'opérateur de flèche peut être surchargé. L'opérateur Arrow est généralement conçu pour être appliqué aux pointeurs (ou aux objets qui se comportent comme des pointeurs, comme des pointeurs intelligents). L'opérateur point ne peut pas être appliqué aux pointeurs.
EDIT Appliqué à l'opérateur de flèche de pointeur équivaut à appliquer l'opérateur de point à pointee (ptr-> champ est équivalent à (* ptr) .field)
L'opérateur de flèche est comme un point, sauf qu'il déréférence d'abord un pointeur. foo.bar() appelle la méthode bar() sur un objet foo, foo->bar appelle la méthode bar sur un objet pointé par le pointeur foo.
L'opérateur . est destiné à un accès direct aux membres.
object.Field
La flèche déréférence un pointeur pour que vous puissiez accéder à l'objet/à la mémoire sur laquelle il pointe.
pClass->Field
pSomething->someMember
est équivalent à
(*pSomething).someMember
La cible. dot travaille sur des objets; La flèche fonctionne sur les pointeurs d’objets.
std::string str("foo");
std::string * pstr = new std::string("foo");
str.size ();
pstr->size ();
Utilisez -> lorsque vous avez un pointeur. Utilisez . lorsque vous avez une structure (classe).
Lorsque vous souhaitez pointer un attribut appartenant à une structure, utilisez .:
structure.attribute
Lorsque vous souhaitez pointer sur un attribut référencé en mémoire par un pointeur, utilisez ->:
pointer->method;
ou identique à:
(*pointer).method
Notez que l'opérateur -> ne peut pas être utilisé pour certaines choses, par exemple, l'accès à l'opérateur [].
#include <vector>
int main()
{
std::vector<int> iVec;
iVec.Push_back(42);
std::vector<int>* iVecPtr = &iVec;
//int i = iVecPtr->[0]; // Does not compile
int i = (*iVecPtr)[0]; // Compiles.
}
Le -> est simplement un sucre syntaxique pour un déréférencement de pointeur,
Comme d'autres l'ont dit:
pointeur-> méthode ();
est une méthode simple de dire:
(* pointeur) .method ();
Pour plus d’amusement de pointeur, consultez Binky et sa baguette magique de déréférencement:
C'est simple, chaque fois que vous voyez
x->y
sais que c'est pareil que
(*x).y
La différence la plus simple entre les deux est que "->" déréférence un pointeur avant de regarder les objets, champs, fonctions, etc. alors que "." ne déréférence pas en premier. Utilisez "->" lorsque vous avez un pointeur sur un objet et utilisez "." lorsque vous travaillez avec l'instance réelle d'un objet.
Une autre méthode équivalente consiste à utiliser d’abord le déréférencement "*" sur le pointeur, puis à utiliser simplement le ".". Nous évitons les intermédiaires en utilisant "->".
Il y a d'autres différences, mais les autres réponses ont largement couvert cela.
Si vous avez un arrière-plan dans Java, vous risquez de vous dérouter car, en Java, tout est un indicateur. Cela signifie qu'il n'y a aucune raison d'avoir un symbole qui ne déréférence pas votre pointeur en premier. Cependant, en c ++, il faut être un peu plus prudent pour se souvenir de ce qui est ou non un pointeur, et il peut être judicieux de les étiqueter avec le préfixe "p_" ou simplement "p".
Le . (point) L'opérateur est généralement utilisé pour obtenir un champ/appel d'une méthode à partir d'une instance de classe (ou d'un champ/méthode statique d'une classe).
p.myField, p.myMethod () - p instance d'une classe
L’opérateur -> (flèche) permet d’obtenir un champ/appel d’une méthode à partir du contenu pointé par la classe.
p-> myField, p-> myMethod () - p pointe sur une classe
L'opérateur -> est utilisé lorsque nous travaillons avec un pointeur et le point est utilisé autrement. Donc, si nous avons une classe de structure comme:
struct class{ int num_students; int yr_grad; };
et nous avons une instance d'une classe * curr_class (pointeur de classe), alors pour avoir accès au nombre d'étudiants, nous ferions
cout << curr_class->num_students << endl;
Dans le cas où nous aurions un objet de classe simple, par exemple class_2016, nous le ferions.
cout << class_2016.num_students << endl;
Pour que le pointeur classe, l'opérateur -> est équivalent à
(*obj).mem_var
Remarque: pour une classe, le moyen d'accéder aux fonctions membres de la classe sera également le même