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

cette question a déjà une réponse ici:

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

272
demandé sur Joe Gauterin 2009-08-06 16:41:06
la source

14 ответов

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++?

282
répondu SwDevMan81 2018-08-06 16:35:50
la source

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

64
répondu Gordon Gustafson 2012-12-08 00:40:29
la source
L'opérateur point

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)

55
répondu Tadeusz Kopec 2009-08-06 16:44:51
la source

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 .

26
répondu Meredith L. Patterson 2009-08-06 16:43:05
la source
pSomething->someMember

est l'équivalent de

(*pSomething).someMember
13
répondu Tamás Szelei 2011-06-23 00:02:37
la source

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
12
répondu Johannes Rudolph 2017-04-19 07:00:18
la source

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 ();
10
répondu ezpz 2009-08-06 16:44:36
la source

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.
}
3
répondu gparent 2009-08-06 16:58:34
la source

c'est simple, quand vous voyez

 x->y

savent que c'est le même que

 (*x).y
2
répondu Logan Capaldo 2009-08-06 16:48:35
la source

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
2
répondu Am1rr3zA 2018-08-31 12:46:35
la source

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

1
répondu Samuel Carrijo 2009-08-06 16:51:10
la source

- > " 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

1
répondu Ali Parr 2009-08-06 17:19:14
la source

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

1
répondu Mads Engberg 2016-02-14 05:16:38
la source

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

1
répondu PYA 2016-02-26 09:54:43
la source

Autres questions sur c++ operators