Quelle est la différence entre le point (.) opérateur et - > en C++? [dupliquer]

foo->bar() est le même que (*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 point ( . ) est évalué en premier (voir priorité de l'opérateur )

l'opérateur Dot ( . ) ne peut pas être surchargé, l'opérateur arrow ( -> ) peut être surcharger.

l'opérateur point ( . ) ne peut pas être appliqué aux pointeurs.

Voir aussi: qu'est-ce que l'opérateur Flèche ( - > ) synonyme de en C++?

pour un pointeur, nous pourrions simplement utiliser

*pointervariable.foo

mais l'opérateur . a une plus grande priorité que l'opérateur * , donc . est évalué en premier. Donc, nous devons forcer cela avec la parenthèse:

(*pointervariable).foo

mais taper le ()'s tout le temps est difficile, 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 d'une référence d'objet, utilisez . si vous accédez à une propriété d'un objet via un pointeur, utilisez ->

ne peut pas être surchargé, l'opérateur flèche peut être surchargé. Arrow operator est généralement destiné à être appliqué à des pointeurs (ou des objets qui se comportent comme des pointeurs, comme des pointeurs intelligents). L'opérateur de point ne peut pas être appliqué aux pointeurs.

EDIT Lorsqu'il est appliqué à l'opérateur Flèche pointeur est équivalent à appliquer l'opérateur point à pointée (ptr->champ est équivalent à (*ptr).field)

l'opérateur de la flèche est comme un point, sauf qu'il déréfère d'abord un pointeur. foo.bar() les appels de méthode bar() sur l'objet foo , foo->bar les appels de méthode bar sur l'objet pointé par le pointeur foo .

pSomething->someMember

est l'équivalent de

(*pSomething).someMember

l'opérateur . est pour l'accès direct des membres.

object.Field

La flèche déréférence un pointeur de sorte que vous pouvez accéder à l'objet/mémoire qu'il pointe vers

pClass->Field

la cible. dot travaille sur des objets; arrow travaille sur des pointeurs vers des objets.

std::string str("foo");
std::string * pstr = new std::string("foo");

str.size ();
pstr->size ();

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.
}

c'est simple, quand vous voyez

 x->y

savent que c'est le même que

 (*x).y

utilisez -> lorsque vous avez pointer. Utilisez . lorsque vous avez une structure (classe).

lorsque vous voulez un attribut de point qui appartient à la structure, utilisez . :

structure.attribute

quand vous voulez Point d'attribut qui ont référence à la mémoire par pointeur utiliser -> :

pointer->method;

ou comme:

(*pointer).method

The . (point) l'opérateur est habituellement utilisé pour obtenir un champ / appeler une méthode à partir d'une instance de classe (ou un champ / méthode statique d'une classe).

p. myField, p. MyMethod () - P instance d'une classe

- > (flèche) opérateur est utilisé pour obtenir un champ / appel d'une méthode à partir du contenu pointé par la classe.

, p->myField, p->myMethod() - p pointe vers une classe

- > " est simplement du 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).méthode ();

pour plus de plaisir à pointer, regardez Binky, et sa baguette magique de déréférencement:

http://www.youtube.com/watch?v=UvoHwFvAvQE

la différence la plus simple entre les deux est que "- > " déréférences un pointeur avant qu'il va à regarder que les objets champs, fonction, etc. alors." "ne pas déréférencer premier. Utiliser "->" quand vous avez un pointeur vers un objet, et l'utilisation "."quand vous travaillez avec l'instance réelle d'un objet.

une autre façon équivalente d'écrire ceci pourrait être d'utiliser le déréférencement " * "sur le pointeur d'abord et ensuite juste utiliser le".". Nous sautons middleman en utilisant" ->".

Il y a d'autres différences, mais les autres réponses ont couvert cette profondeur.

si vous avez un arrière-plan en Java, cela pourrait vous embrouiller, puisque, en Java, tout est pointeur. Cela signifie qu'il n'y a aucune raison d'avoir un symbole qui ne déréférente pas votre pointeur en premier. En c++, cependant, vous devez être un peu plus prudent en vous rappelant ce qui est et ce qui n'est pas un pointeur, et ce pourrait être une bonne idée de les étiqueter avec le préfixe " p_ " ou tout simplement "p".

- > opérateur est utilisé lorsque l'on travaille avec un pointeur et le point est utilisé autrement. Donc, si nous avons une classe de struct comme:

struct class{ int num_students; int yr_grad; };

et nous avons une instance d'une classe* curr_class (pointeur de classe), puis d'obtenir l'accès à nombre d'étudiants que nous ferions 151950920"

cout << curr_class->num_students << endl;

dans le cas où nous aurions un objet de classe simple, disons class_2016, nous ferions

cout << class_2016.num_students << endl;

Pour le pointeur vers la classe -> opérateur est équivalent à

(*obj).mem_var

Note: pour une classe, la manière d'accéder aux fonctions de membre de la classe sera également la même